示例#1
0
class DeployManager( SceneEditorModule ):
	def __init__(self):
		super( DeployManager, self ).__init__()

	def getName( self ):
		return 'deploy_manager'

	def getDependency( self ):
		return [ 'mock' ]

	def onLoad( self ):
		self.configPath = self.getProject().getConfigPath( _DEPLOY_CONFIG_FILE )
		#UI
		self.container = self.requestDocumentWindow( 'DeployManager',
			title     = 'Deployment Manager',
			allowDock = False,
			minSize   = ( 300, 300 ),
			maxSize   = ( 300, 300 )
			)

		#Components
		self.window = self.container.addWidgetFromFile( _getModulePath('DeployManager.ui') )

		self.delegate = MOAILuaDelegate( self )
		self.delegate.load( _getModulePath( 'DeployManager.lua' ) )

		#scene tree
		layout = QtGui.QVBoxLayout()
		self.window.containerSceneTree.setLayout( layout )
		layout.setSpacing( 0 )
		layout.setMargin( 0 )

		self.treeScene = DeploySceneTree( 
			self.window.containerSceneTree,
			editable = True,
			sorting  = False,
			multiple_selection = False
			)
		self.treeScene.manager = self
		layout.addWidget( self.treeScene )

		sceneToolbar = QtGui.QToolBar( self.window.containerSceneTree )
		layout.addWidget( sceneToolbar )
		self.sceneTool = self.addToolBar( 'deploy_scene', sceneToolbar )
		self.addTool( 'deploy_scene/add_scene',         label = 'add'     ,icon = 'add'    )
		self.addTool( 'deploy_scene/remove_scene',      label = 'remove'  ,icon = 'remove' )
		self.addTool( 'deploy_scene/move_up_scene',     label = 'up'      ,icon = 'arrow-up'     )
		self.addTool( 'deploy_scene/move_down_scene',   label = 'down'    ,icon = 'arrow-down'   )
		self.addTool( 'deploy_scene/----' )
		self.addTool( 'deploy_scene/edit_scene',   label = 'change target scene' ,icon = 'pencil'   )
		self.addTool( 'deploy_scene/----' )
		self.addTool( 'deploy_scene/set_entry_scene',   label = 'set as entry' ,icon = 'flag'   )

		#deploy target tree
		layout = QtGui.QVBoxLayout()
		self.window.containerTargetTree.setLayout( layout )
		layout.setSpacing( 0 )		
		layout.setMargin( 0 )

		self.treeTarget = DeployTargetTree( 
			self.window.containerTargetTree,
			editable = True,
			multiple_selection = False
			)
		self.treeTarget.manager = self
		layout.addWidget( self.treeTarget )

		targetToolbar = QtGui.QToolBar( self.window.containerTargetTree )
		layout.addWidget( targetToolbar )
		self.targetTool = self.addToolBar( 'deploy_target', targetToolbar )
		self.addTool( 'deploy_target/add_target',    label = '+' )
		self.addTool( 'deploy_target/remove_target', label = '-' )

		#target property
		self.propertyTarget = addWidgetWithLayout(
			PropertyEditor( self.window.containerTargetProp )
		)

		#menu
		self.addMenuItem( 'main/file/----' )
		self.addMenuItem( 'main/file/deploy_manager', 
			dict( label = 'Deploy Manager', shortcut = 'F11' )
			)

		self.addMenuItem( 'main/file/deploy_build', 
			dict( label = 'Deploy Build', shortcut = 'Ctrl+F11' )
			)
		
		
		# self.container.show()
		self.window.buttonOK.clicked.connect( self.onButtonOK )

		#other
		registerSearchEnumerator( deployTargetSearchEnumerator )

		signals.connect( 'project.pre_deploy', self.preDeploy )
		signals.connect( 'project.deploy', self.onDeploy )
		signals.connect( 'project.post_deploy', self.postDeploy )


	def onStart( self ):
		#load config
		self.loadConfig()
		#fill trees
		self.treeTarget.rebuild()
		self.treeScene.rebuild()

	def onStop( self ):
		self.saveConfig()

	def loadConfig( self ):
		self.delegate.safeCall( 'loadDeployManagerConfig', self.configPath )

	def saveConfig( self ):
		self.delegate.safeCall( 'saveDeployManagerConfig', self.configPath )		

	def getDeployTargetTypes( self ):
		registry = self.delegate.safeCall( 'getDeployTargetTypeRegistry' )
		return [ name for name in registry.keys() ]

	def getDeployTargets( self ):
		targets =  self.delegate.safeCallMethod( 'config', 'getTargets' )
		return [ obj for obj in targets.values() ]

	def addDeployTarget( self, targetType ):
		target = self.delegate.safeCallMethod( 'config', 'addDeployTarget', targetType )
		self.treeTarget.addNode( target )
		self.treeTarget.editNode( target )

	def changeDeployScene( self, targetScene ):
		for sceneEntry in self.treeScene.getSelection():
			self.delegate.safeCallMethod( 'config', 'changeTargetScene', sceneEntry, targetScene.getPath() )
			self.treeScene.refreshNode( sceneEntry )
			return

	def renameDeployTarget( self, target, name ):
		target.name = name #avoid duplicated name

	def addDeployScene( self, sceneNode ):
		if not sceneNode: return
		entry = self.delegate.safeCallMethod( 'config', 'addDeployScene', sceneNode.getNodePath() )
		self.treeScene.addNode( entry )
		self.treeScene.editNode( entry )

	def renameDeployScene( self, entry, alias ):
		entry.alias = alias #TODO: avoid duplicated name

	def getDeployScenes( self ):
		scenes =  self.delegate.safeCallMethod( 'config', 'getScenes' )
		return [ obj for obj in scenes.values() ]

	def updateGameConfig( self ):
		self.delegate.safeCallMethod( 'config', 'updateGameConfig' )

	def preDeploy( self, context ):
		self.updateGameConfig()

	def onDeploy( self, context ):
		pass

	def postDeploy( self, context ):
		pass

	def onTool( self, tool ):
		name = tool.name
		if name == 'add_target':
			requestSearchView( 
				info    = 'select deploy target type',
				context = 'deploy_target_type',
				on_selection = self.addDeployTarget
				)

		elif name == 'remove_target':
			for target in self.treeTarget.getSelection():
				self.treeTarget.removeNode( target )
				self.delegate.safeCallMethod( 'config', 'removeDeployTarget', target )

		elif name == 'add_scene':
			requestSearchView( 
				info    = 'select scene to deploy',
				context = 'asset',
				type    = 'scene',
				on_selection = self.addDeployScene
				)

		elif name == 'edit_scene':
			requestSearchView( 
				info    = 'select new target scene ',
				context = 'asset',
				type    = 'scene',
				on_selection = self.changeDeployScene
				)

		elif name == 'remove_scene':
			for entry in self.treeScene.getSelection():	
				self.delegate.safeCallMethod( 'config', 'removeDeployScene', entry )
				self.treeScene.removeNode( entry )
			self.treeScene.refreshAllContent()

		elif name == 'set_entry_scene':
			for entry in self.treeScene.getSelection():
				self.delegate.safeCallMethod( 'config', 'setEntryScene', entry )
				break
			self.treeScene.refreshAllContent()

		elif name == 'move_up_scene':
			for target in self.treeScene.getSelection():
				self.delegate.safeCallMethod( 'config', 'moveSceneUp', target )
				self.treeScene.rebuild()
				self.treeScene.selectNode( target )
				break

		elif name == 'move_down_scene':
			for target in self.treeScene.getSelection():
				self.delegate.safeCallMethod( 'config', 'moveSceneDown', target )
				self.treeScene.rebuild()
				self.treeScene.selectNode( target )
				break

	def onMenu( self, node ):
		name = node.name
		if name == 'deploy_manager' :
			self.onSetFocus()

		elif name == 'deploy_build':
			app.getProject().deploy()

	def onSetFocus( self ):
		self.container.show()
		self.container.raise_()
	
	def onButtonOK( self ):
		self.saveConfig()
		self.container.hide()
示例#2
0
class SceneReferenceEditor(SceneEditorModule):
    def __init__(self):
        super(SceneReferenceEditor, self).__init__()
        self.refreshScheduled = False

    def getName(self):
        return 'global_object_manager'

    def getDependency(self):
        return ['scene_editor', 'mock']

    def onLoad(self):
        #UI
        self.window = self.requestDockWindow('SceneReferenceEditor',
                                             title='Scene Reference',
                                             size=(120, 120),
                                             minSize=(120, 120),
                                             dock='right')

        #Components
        self.tree = self.window.addWidget(
            SceneReferenceTreeWidget(multiple_selection=True,
                                     editable=True,
                                     drag_mode='internal'))

        self.tool = self.addToolBar('global_object_manager',
                                    self.window.addToolBar())
        self.delegate = MOAILuaDelegate(self)
        self.delegate.load(_getModulePath('SceneReferenceEditor.lua'))

        self.addTool('global_object_manager/add_group',
                     label='Add Group',
                     icon='add_folder')
        self.addTool('global_object_manager/add', label='Add', icon='add')
        self.addTool('global_object_manager/remove',
                     label='Remove',
                     icon='remove')

        if self.getModule('introspector'):
            import SceneReferenceNodeEditor

        registerSearchEnumerator(globalObjectNameSearchEnumerator)
        registerSearchEnumerator(globalObjectSearchEnumerator)

    def onAppReady(self):
        self.tree.rebuild()

    def onMoaiClean(self):
        self.tree.clear()

    def onTool(self, tool):
        name = tool.name
        if name == 'add':
            requestSearchView(
                info='select global object class to create',
                context='global_object_class',
                on_selection=lambda objName: self.createGlobalObject(objName))

        if name == 'add_group':
            group = self.delegate.safeCall('addGroup')
            self.tree.addNode(group)
            self.tree.editNode(group)
            self.tree.selectNode(group)

        elif name == 'remove':
            for node in self.tree.getSelection():
                self.doCommand('scene_editor/remove_global_object',
                               target=node)
                self.tree.removeNode(node)

        elif name == 'refresh':
            self.scheduleRefreshObject()

    def onMenu(self, menu):
        if menu.name == 'find_global_object':
            requestSearchView(
                info='search for global object',
                context='global_object',
                on_selection=lambda node: self.selectObject(node, True))

    def needUpdate(self):
        return True

    def onUpdate(self):
        if self.refreshScheduled:
            self.refreshScheduled = False
            self.delegate.safeCall('reloadObjects')
            self.tree.rebuild()

    def scheduleRefreshObject(self):
        self.refreshScheduled = True

    def selectObject(self, target, updateTree=False):
        self.changeSelection(target)
        if updateTree:
            self.tree.blockSignals(True)
            self.tree.selectNode(None)
            if isinstance(target, list):
                for e in target:
                    self.tree.selectNode(e, add=True)
            else:
                self.tree.selectNode(target)
            self.tree.blockSignals(False)

    def renameObject(self, obj, name):
        obj.setName(obj, name)

    def createGlobalObject(self, objName):
        self.doCommand('scene_editor/create_global_object', name=objName)

    def onObjectAdded(self, node, reason='new'):
        self.tree.addNode(node)
        if reason == 'new':
            self.tree.editNode(node)
            self.tree.selectNode(node)

    def onObjectRemoved(self, node):
        self.tree.removeNode(node)

    def onObjectRenamed(self, node, name):
        self.tree.refreshNodeContent(node)
示例#3
0
class GlobalObjectManager( SceneEditorModule ):
	def __init__(self):
		super( GlobalObjectManager, self ).__init__()
		self.refreshScheduled = False

	def getName( self ):
		return 'global_object_manager'

	def getDependency( self ):
		return [ 'scene_editor', 'mock' ]

	def onLoad( self ):
		#UI
		self.window = self.requestDockWindow( 'GlobalObjectManager',
			title     = 'Global Objects',
			size      = (120,120),
			minSize   = (120,120),
			dock      = 'left'
			)

		#Components
		self.tree = self.window.addWidget( 
				GlobalObjectTreeWidget( 
					multiple_selection = True,
					editable           = True,
					drag_mode          = 'internal'
				)
			)

		self.tool = self.addToolBar( 'global_object_manager', self.window.addToolBar() )
		self.delegate = MOAILuaDelegate( self )
		self.delegate.load( _getModulePath( 'GlobalObjectManager.lua' ) )

		# self.creatorMenu=self.addMenu(
		# 	'global_object_create',
		# 	{ 'label':'Create Global Object' }
		# 	)

		self.addTool( 'global_object_manager/add',    label = 'Add', icon = 'add' )
		self.addTool( 'global_object_manager/remove', label = 'Remove', icon = 'remove' )
		self.addTool( 'global_object_manager/clone',  label = 'Clone', icon = 'clone' )
		self.addTool( 'global_object_manager/add_group',    label = 'Add Group', icon = 'add_folder' )
		self.addTool( 'global_object_manager/----' )
		self.addTool( 'global_object_manager/refresh',    label = 'Refresh', icon = 'refresh' )
		
		# self.addMenuItem( 'main/find/find_global_object', 
		# 	dict( label = 'Find In Global Objects', shortcut = 'ctrl+alt+f' ) )

		#SIGNALS
		signals.connect( 'moai.clean', self.onMoaiClean )

		signals.connect( 'global_object.added',   self.onObjectAdded )
		signals.connect( 'global_object.removed', self.onObjectRemoved )
		signals.connect( 'global_object.renamed', self.onObjectRenamed )

		if self.getModule('introspector'):
			import GlobalObjectNodeEditor

		registerSearchEnumerator( globalObjectNameSearchEnumerator )
		registerSearchEnumerator( globalObjectSearchEnumerator )

	def onAppReady( self ):
		self.tree.rebuild()
		self.tree.setColumnWidth( 0, 150 )

	def onMoaiClean( self ):
		self.tree.clear()

	def onTool( self, tool ):
		name = tool.name
		if name == 'add':
			requestSearchView( 
				info    = 'select global object class to create',
				context = 'global_object_class',
				on_selection = lambda objName: self.createGlobalObject( objName )				
				)

		if name == 'add_group':
			group = self.delegate.safeCall( 'addGroup' )
			self.tree.addNode( group )
			self.tree.editNode( group )
			self.tree.selectNode( group )

		elif name == 'remove':
			for node in self.tree.getSelection():
				self.doCommand( 'scene_editor/remove_global_object', target = node )
				self.tree.removeNode( node )

		elif name == 'refresh':
			self.scheduleRefreshObject()

	def onMenu( self, menu ):
		if menu.name == 'find_global_object':
			requestSearchView( 
				info    = 'search for global object',
				context = 'global_object',				
				on_selection = lambda node: self.selectObject( node, True )
				)

	def needUpdate( self ):
		return True
		
	def onUpdate( self ):
		if self.refreshScheduled :
			self.refreshScheduled = False
			self.delegate.safeCall( 'reloadObjects' )
			self.tree.rebuild()

	def scheduleRefreshObject( self ):
		self.refreshScheduled = True

	def selectObject( self, target, updateTree = False ):
		self.changeSelection( target )
		if updateTree:
			self.tree.blockSignals( True )
			self.tree.selectNode( None )
			if isinstance( target, list ):
				for e in target:
					self.tree.selectNode( e, add = True)
			else:
				self.tree.selectNode( target )
			self.tree.blockSignals( False )

	def renameObject( self, obj, name ):
		obj.setName( obj, name )

	def createGlobalObject( self, objName ):
		self.doCommand( 'scene_editor/create_global_object', name = objName )

	def onObjectAdded( self, node, reason = 'new' ):
		self.tree.addNode( node )
		if reason == 'new':
			self.tree.editNode( node )
			self.tree.selectNode( node )

	def onObjectRemoved( self, node ):
		self.tree.removeNode( node )

	def onObjectRenamed( self, node, name ):
		self.tree.refreshNodeContent( node )
示例#4
0
class LayerManager(SceneEditorModule):
    def __init__(self):
        super(LayerManager, self).__init__()

    def getName(self):
        return 'layer_manager'

    def getDependency(self):
        return ['scene_editor', 'mock']

    def onLoad(self):
        #UI
        self.windowTitle = 'Layers'
        self.window = self.requestDockWindow('LayerManager',
                                             title='Layers',
                                             size=(120, 120),
                                             minSize=(120, 120),
                                             dock='left')

        #Components
        self.treeFilter = self.window.addWidget(GenericTreeFilter(),
                                                expanding=False)
        self.tree = self.window.addWidget(
            LayerTreeWidget(self.window,
                            multiple_selection=False,
                            sorting=False,
                            editable=True,
                            drag_mode='internal'))
        self.tree.hasSoloLayer = False
        self.treeFilter.setTargetTree(self.tree)

        self.tool = self.addToolBar('layer_manager', self.window.addToolBar())
        self.delegate = MOAILuaDelegate(self)
        self.delegate.load(_getModulePath('LayerManager.lua'))

        self.addTool('layer_manager/add', label='add', icon='add')
        self.addTool('layer_manager/remove', label='remove', icon='remove')
        self.addTool('layer_manager/up', label='up', icon='arrow-up')
        self.addTool('layer_manager/down', label='down', icon='arrow-down')

        #SIGNALS
        signals.connect('moai.clean', self.onMoaiClean)

    def onAppReady(self):
        self.tree.rebuild()

    def onMoaiClean(self):
        self.tree.clear()

    def onTool(self, tool):
        name = tool.name
        if name == 'add':
            layer = self.delegate.safeCall('addLayer')
            self.tree.addNode(layer)
            self.tree.editNode(layer)
            self.tree.selectNode(layer)

        elif name == 'remove':
            for l in self.tree.getSelection():
                self.delegate.safeCall('removeLayer', l)
                self.tree.removeNode(l)
        elif name == 'up':
            for l in self.tree.getSelection():
                self.delegate.safeCall('moveLayerUp', l)
                self.tree.rebuild()
                self.tree.selectNode(l)
                break
        elif name == 'down':
            for l in self.tree.getSelection():
                self.delegate.safeCall('moveLayerDown', l)
                self.tree.rebuild()
                self.tree.selectNode(l)
                break

    def changeLayerName(self, layer, name):
        layer.setName(layer, name)

    def toggleHidden(self, layer):
        layer.setVisible(layer, not layer.isVisible(layer))
        self.tree.refreshNodeContent(layer)
        signals.emit('scene.update')

    def toggleEditVisible(self, layer):
        layer.setEditorVisible(layer, not layer.isEditorVisible(layer))
        self.tree.refreshNodeContent(layer)
        signals.emit('scene.update')

    def toggleLock(self, layer):
        layer.locked = not layer.locked
        self.tree.refreshNodeContent(layer)
        signals.emit('scene.update')

    def toggleSolo(self, layer):
        solo = layer.isEditorSolo(layer)
        if solo:
            self.tree.hasSoloLayer = False
            for l in list(_MOCK.game.layers.values()):
                if l.name == '_GII_EDITOR_LAYER': continue
                if l != layer:
                    l.editorSolo = False
            layer.setEditorSolo(layer, False)
        else:
            self.tree.hasSoloLayer = True
            for l in list(_MOCK.game.layers.values()):
                if l.name == '_GII_EDITOR_LAYER': continue
                if l != layer:
                    l.editorSolo = 'hidden'
            layer.setEditorSolo(layer, True)
        self.tree.refreshAllContent()
        signals.emit('scene.update')
示例#5
0
class LayerManager( SceneEditorModule ):
	def __init__(self):
		super( LayerManager, self ).__init__()

	def getName( self ):
		return 'layer_manager'

	def getDependency( self ):
		return [ 'scene_editor', 'mock' ]

	def onLoad( self ):
		#UI
		self.windowTitle = 'Layers'
		self.window = self.requestDockWindow( 'LayerManager',
			title     = 'Layers',
			size      = (120,120),
			minSize   = (120,120),
			dock      = 'left'
			)

		#Components
		self.treeFilter = self.window.addWidget( GenericTreeFilter() )
		self.tree = self.window.addWidget( 
			LayerTreeWidget(
				self.window,
				multiple_selection = False,
				sorting            = False,
				editable           = True,
				drag_mode          = 'internal'
				)
			)
		self.tree.hasSoloLayer = False
		self.treeFilter.setTargetTree( self.tree )

		self.tool = self.addToolBar( 'layer_manager', self.window.addToolBar() )
		self.delegate = MOAILuaDelegate( self )
		self.delegate.load( _getModulePath( 'LayerManager.lua' ) )

		self.addTool( 'layer_manager/add',    label = 'add',  icon = 'add' )
		self.addTool( 'layer_manager/remove', label = 'remove', icon = 'remove' )
		self.addTool( 'layer_manager/up',     label = 'up', icon = 'arrow-up' )
		self.addTool( 'layer_manager/down',   label = 'down', icon = 'arrow-down' )

		
		#SIGNALS
		signals.connect( 'moai.clean', self.onMoaiClean )

	def onAppReady( self ):
		self.tree.rebuild()

	def onMoaiClean( self ):
		self.tree.clear()

	def onTool( self, tool ):
		name = tool.name
		if name == 'add':
			layer = self.delegate.safeCall( 'addLayer' )
			self.tree.addNode( layer )
			self.tree.editNode( layer )
			self.tree.selectNode( layer )
			
		elif name == 'remove':
			for l in self.tree.getSelection():
				self.delegate.safeCall( 'removeLayer', l )
				self.tree.removeNode( l )
		elif name == 'up':
			for l in self.tree.getSelection():
				self.delegate.safeCall( 'moveLayerUp', l )
				self.tree.rebuild()
				self.tree.selectNode( l )
				break
		elif name == 'down':
			for l in self.tree.getSelection():
				self.delegate.safeCall( 'moveLayerDown', l )		
				self.tree.rebuild()
				self.tree.selectNode( l )
				break

	def changeLayerName( self, layer, name ):
		layer.setName( layer, name )

	def toggleHidden( self, layer ):
		layer.setVisible( layer, not layer.isVisible( layer ) )
		self.tree.refreshNodeContent( layer )
		signals.emit( 'scene.update' )

	def toggleEditVisible( self, layer ):
		layer.setEditorVisible( layer, not layer.isEditorVisible( layer ) )
		self.tree.refreshNodeContent( layer )
		signals.emit( 'scene.update' )

	def toggleLock( self, layer ):
		layer.locked = not layer.locked
		self.tree.refreshNodeContent( layer )
		signals.emit( 'scene.update' )

	def toggleSolo( self, layer ):
		solo = layer.isEditorSolo( layer )
		if solo:
			self.tree.hasSoloLayer = False
			for l in _MOCK.game.layers.values():
				if l.name == '_GII_EDITOR_LAYER' : continue
				if l != layer:
					l.editorSolo = False
			layer.setEditorSolo( layer, False )
		else:
			self.tree.hasSoloLayer = True
			for l in _MOCK.game.layers.values():
				if l.name == '_GII_EDITOR_LAYER' : continue
				if l != layer:
					l.editorSolo = 'hidden'
			layer.setEditorSolo( layer, True )
		self.tree.refreshAllContent()
		signals.emit( 'scene.update' )
示例#6
0
class DeployManager(SceneEditorModule):
    def __init__(self):
        super(DeployManager, self).__init__()

    def getName(self):
        return 'deploy_manager'

    def getDependency(self):
        return ['mock']

    def onLoad(self):
        self.configPath = self.getProject().getConfigPath(_DEPLOY_CONFIG_FILE)
        #UI
        self.container = self.requestDocumentWindow('DeployManager',
                                                    title='Deployment Manager',
                                                    allowDock=False,
                                                    minSize=(300, 300),
                                                    maxSize=(300, 300))

        #Components
        self.window = self.container.addWidgetFromFile(
            _getModulePath('DeployManager.ui'))

        self.delegate = MOAILuaDelegate(self)
        self.delegate.load(_getModulePath('DeployManager.lua'))

        #scene tree
        layout = QtGui.QVBoxLayout()
        self.window.containerSceneTree.setLayout(layout)
        layout.setSpacing(0)
        layout.setMargin(0)

        self.treeScene = DeploySceneTree(self.window.containerSceneTree,
                                         editable=True,
                                         sorting=False,
                                         multiple_selection=False)
        self.treeScene.manager = self
        layout.addWidget(self.treeScene)

        sceneToolbar = QtGui.QToolBar(self.window.containerSceneTree)
        layout.addWidget(sceneToolbar)
        self.sceneTool = self.addToolBar('deploy_scene', sceneToolbar)
        self.addTool('deploy_scene/add_scene', label='add', icon='add')
        self.addTool('deploy_scene/remove_scene',
                     label='remove',
                     icon='remove')
        self.addTool('deploy_scene/move_up_scene', label='up', icon='arrow-up')
        self.addTool('deploy_scene/move_down_scene',
                     label='down',
                     icon='arrow-down')
        self.addTool('deploy_scene/----')
        self.addTool('deploy_scene/edit_scene',
                     label='change target scene',
                     icon='pencil')
        self.addTool('deploy_scene/----')
        self.addTool('deploy_scene/set_entry_scene',
                     label='set as entry',
                     icon='flag')

        #deploy target tree
        layout = QtGui.QVBoxLayout()
        self.window.containerTargetTree.setLayout(layout)
        layout.setSpacing(0)
        layout.setMargin(0)

        self.treeTarget = DeployTargetTree(self.window.containerTargetTree,
                                           editable=True,
                                           multiple_selection=False)
        self.treeTarget.manager = self
        layout.addWidget(self.treeTarget)

        targetToolbar = QtGui.QToolBar(self.window.containerTargetTree)
        layout.addWidget(targetToolbar)
        self.targetTool = self.addToolBar('deploy_target', targetToolbar)
        self.addTool('deploy_target/add_target', label='+')
        self.addTool('deploy_target/remove_target', label='-')

        #target property
        self.propertyTarget = addWidgetWithLayout(
            PropertyEditor(self.window.containerTargetProp))

        #menu
        self.addMenuItem('main/file/----')
        self.addMenuItem('main/file/deploy_manager',
                         dict(label='Deploy Manager', shortcut='F11'))

        self.addMenuItem('main/file/deploy_build',
                         dict(label='Deploy Build', shortcut='Ctrl+F11'))

        # self.container.show()
        self.window.buttonOK.clicked.connect(self.onButtonOK)

        #other
        registerSearchEnumerator(deployTargetSearchEnumerator)

        signals.connect('project.pre_deploy', self.preDeploy)
        signals.connect('project.deploy', self.onDeploy)
        signals.connect('project.post_deploy', self.postDeploy)

    def onStart(self):
        #load config
        self.loadConfig()
        #fill trees
        self.treeTarget.rebuild()
        self.treeScene.rebuild()

    def onStop(self):
        self.saveConfig()

    def loadConfig(self):
        self.delegate.safeCall('loadDeployManagerConfig', self.configPath)

    def saveConfig(self):
        self.delegate.safeCall('saveDeployManagerConfig', self.configPath)

    def getDeployTargetTypes(self):
        registry = self.delegate.safeCall('getDeployTargetTypeRegistry')
        return [name for name in registry.keys()]

    def getDeployTargets(self):
        targets = self.delegate.safeCallMethod('config', 'getTargets')
        return [obj for obj in targets.values()]

    def addDeployTarget(self, targetType):
        target = self.delegate.safeCallMethod('config', 'addDeployTarget',
                                              targetType)
        self.treeTarget.addNode(target)
        self.treeTarget.editNode(target)

    def changeDeployScene(self, targetScene):
        for sceneEntry in self.treeScene.getSelection():
            self.delegate.safeCallMethod('config', 'changeTargetScene',
                                         sceneEntry, targetScene.getPath())
            self.treeScene.refreshNode(sceneEntry)
            return

    def renameDeployTarget(self, target, name):
        target.name = name  #avoid duplicated name

    def addDeployScene(self, sceneNode):
        if not sceneNode: return
        entry = self.delegate.safeCallMethod('config', 'addDeployScene',
                                             sceneNode.getNodePath())
        self.treeScene.addNode(entry)
        self.treeScene.editNode(entry)

    def renameDeployScene(self, entry, alias):
        entry.alias = alias  #TODO: avoid duplicated name

    def getDeployScenes(self):
        scenes = self.delegate.safeCallMethod('config', 'getScenes')
        return [obj for obj in scenes.values()]

    def updateGameConfig(self):
        self.delegate.safeCallMethod('config', 'updateGameConfig')

    def preDeploy(self, context):
        self.updateGameConfig()

    def onDeploy(self, context):
        pass

    def postDeploy(self, context):
        pass

    def onTool(self, tool):
        name = tool.name
        if name == 'add_target':
            requestSearchView(info='select deploy target type',
                              context='deploy_target_type',
                              on_selection=self.addDeployTarget)

        elif name == 'remove_target':
            for target in self.treeTarget.getSelection():
                self.treeTarget.removeNode(target)
                self.delegate.safeCallMethod('config', 'removeDeployTarget',
                                             target)

        elif name == 'add_scene':
            requestSearchView(info='select scene to deploy',
                              context='asset',
                              type='scene',
                              on_selection=self.addDeployScene)

        elif name == 'edit_scene':
            requestSearchView(info='select new target scene ',
                              context='asset',
                              type='scene',
                              on_selection=self.changeDeployScene)

        elif name == 'remove_scene':
            for entry in self.treeScene.getSelection():
                self.delegate.safeCallMethod('config', 'removeDeployScene',
                                             entry)
                self.treeScene.removeNode(entry)
            self.treeScene.refreshAllContent()

        elif name == 'set_entry_scene':
            for entry in self.treeScene.getSelection():
                self.delegate.safeCallMethod('config', 'setEntryScene', entry)
                break
            self.treeScene.refreshAllContent()

        elif name == 'move_up_scene':
            for target in self.treeScene.getSelection():
                self.delegate.safeCallMethod('config', 'moveSceneUp', target)
                self.treeScene.rebuild()
                self.treeScene.selectNode(target)
                break

        elif name == 'move_down_scene':
            for target in self.treeScene.getSelection():
                self.delegate.safeCallMethod('config', 'moveSceneDown', target)
                self.treeScene.rebuild()
                self.treeScene.selectNode(target)
                break

    def onMenu(self, node):
        name = node.name
        if name == 'deploy_manager':
            self.onSetFocus()

        elif name == 'deploy_build':
            app.getProject().deploy()

    def onSetFocus(self):
        self.container.show()
        self.container.raise_()

    def onButtonOK(self):
        self.saveConfig()
        self.container.hide()
示例#7
0
class GlobalObjectManager(SceneEditorModule):
    def __init__(self):
        super(GlobalObjectManager, self).__init__()
        self.refreshScheduled = False

    def getName(self):
        return 'global_object_manager'

    def getDependency(self):
        return ['scene_editor', 'mock']

    def onLoad(self):
        #UI
        self.window = self.requestDockWindow('GlobalObjectManager',
                                             title='Global Objects',
                                             size=(120, 120),
                                             minSize=(120, 120),
                                             dock='left')

        #Components
        self.treeFilter = self.window.addWidget(GenericTreeFilter(),
                                                expanding=False)
        self.tree = self.window.addWidget(
            GlobalObjectTreeWidget(multiple_selection=True,
                                   editable=True,
                                   drag_mode='internal'))
        self.treeFilter.setTargetTree(self.tree)

        self.tool = self.addToolBar('global_object_manager',
                                    self.window.addToolBar())
        self.delegate = MOAILuaDelegate(self)
        self.delegate.load(_getModulePath('GlobalObjectManager.lua'))

        # self.creatorMenu=self.addMenu(
        # 	'global_object_create',
        # 	{ 'label':'Create Global Object' }
        # 	)

        self.addTool('global_object_manager/add', label='Add', icon='add')
        self.addTool('global_object_manager/remove',
                     label='Remove',
                     icon='remove')
        self.addTool('global_object_manager/clone',
                     label='Clone',
                     icon='clone')
        self.addTool('global_object_manager/add_group',
                     label='Add Group',
                     icon='add_folder')
        self.addTool('global_object_manager/----')
        self.addTool('global_object_manager/refresh',
                     label='Refresh',
                     icon='refresh')

        # self.addMenuItem( 'main/find/find_global_object',
        # 	dict( label = 'Find In Global Objects', shortcut = 'ctrl+alt+f' ) )

        #SIGNALS
        signals.connect('moai.clean', self.onMoaiClean)

        signals.connect('global_object.added', self.onObjectAdded)
        signals.connect('global_object.removed', self.onObjectRemoved)
        signals.connect('global_object.renamed', self.onObjectRenamed)

        if self.getModule('introspector'):
            from . import GlobalObjectNodeEditor

        registerSearchEnumerator(globalObjectNameSearchEnumerator)
        registerSearchEnumerator(globalObjectSearchEnumerator)

    def onAppReady(self):
        self.tree.rebuild()
        self.tree.setColumnWidth(0, 150)

    def onMoaiClean(self):
        self.tree.clear()

    def onTool(self, tool):
        name = tool.name
        if name == 'add':
            requestSearchView(
                info='select global object class to create',
                context='global_object_class',
                on_selection=lambda objName: self.createGlobalObject(objName))

        if name == 'add_group':
            group = self.delegate.safeCall('addGroup')
            self.tree.addNode(group)
            self.tree.editNode(group)
            self.tree.selectNode(group)

        elif name == 'remove':
            for node in self.tree.getSelection():
                self.doCommand('scene_editor/remove_global_object',
                               target=node)
                self.tree.removeNode(node)

        elif name == 'refresh':
            self.scheduleRefreshObject()

    def onMenu(self, menu):
        if menu.name == 'find_global_object':
            requestSearchView(
                info='search for global object',
                context='global_object',
                on_selection=lambda node: self.selectObject(node, True))

    def needUpdate(self):
        return True

    def onUpdate(self):
        if self.refreshScheduled:
            self.refreshScheduled = False
            self.delegate.safeCall('reloadObjects')
            self.tree.rebuild()

    def scheduleRefreshObject(self):
        self.refreshScheduled = True

    def selectObject(self, target, updateTree=False):
        self.changeSelection(target)
        if updateTree:
            self.tree.blockSignals(True)
            self.tree.selectNode(None)
            if isinstance(target, list):
                for e in target:
                    self.tree.selectNode(e, add=True)
            else:
                self.tree.selectNode(target)
            self.tree.blockSignals(False)

    def renameObject(self, obj, name):
        obj.setName(obj, name)

    def createGlobalObject(self, objName):
        self.doCommand('scene_editor/create_global_object', name=objName)

    def reparentObject(self, sources, target):
        if self.doCommand('scene_editor/reparent_global_object',
                          sources=sources,
                          target=target):
            return True

    def onObjectAdded(self, node, reason='new'):
        self.tree.addNode(node)
        if reason == 'new':
            self.tree.editNode(node)
            self.tree.selectNode(node)

    def onObjectRemoved(self, node):
        self.tree.removeNode(node)

    def onObjectRenamed(self, node, name):
        self.tree.refreshNodeContent(node)