def add_path_to_search_project(self):
fname = self.showOpenProjectDialog()
if fname:
pm = ProjectManager()
pm.repositories.append(fname)
pm.write_settings()
self.refresh_project_list()
def add_path_to_search_project(self):
fname = self.showOpenProjectDialog()
if fname:
pm = ProjectManager()
pm.repositories.append(fname)
pm.write_settings()
self.refresh_project_list()
def test_load_project():
from openalea.core.project.manager import ProjectManager
project_manager = ProjectManager()
project = project_manager.load('test_project', '.')
if not project.started:
project.start()
interp.user_ns['project_manager'] = project_manager
interp.user_ns['project'] = project
return True
def test_load_project():
from openalea.core.project.manager import ProjectManager
project_manager = ProjectManager()
project = project_manager.load('test_project', '.')
if not project.started:
project.start()
interp.user_ns['project_manager'] = project_manager
interp.user_ns['project'] = project
return True
def __init__(self):
QtGui.QTreeView.__init__(self)
self._model = ProjectManagerModel()
self.pm = ProjectManager()
self.setModel(self._model)
self._model.dataChanged.connect(self._on_model_changed)
self.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
self.connect(self, QtCore.SIGNAL('doubleClicked(const QModelIndex&)'),
self.open)
self.setHeaderHidden(True)
self.setDragEnabled(True)
self.setDropIndicatorShown(True)
self.setAcceptDrops(True)
self._actions = []
self._new_file_actions = {}
self.paradigms_actions = []
self.paradigms = {}
self.actionEditMeta = QtGui.QAction(qicon("book.png"),
"Edit Project Information", self)
self.actionEditMeta.triggered.connect(self.edit_metadata)
self.actionImportFile = QtGui.QAction(qicon("open.png"), "Import file",
self)
self.actionImportFile.triggered.connect(self.import_file)
self.actionSaveProjAs = QtGui.QAction(qicon("save.png"), "Save As",
self)
self.actionSaveProjAs.triggered.connect(self.save_as)
self.actionSaveProj = QtGui.QAction(qicon("save.png"), "Save project",
self)
self.actionSaveProj.triggered.connect(self.save)
self.actionSaveProj.setShortcut(
QtGui.QApplication.translate("MainWindow", "Ctrl+Shift+S", None,
QtGui.QApplication.UnicodeUTF8))
self.actionCloseProj = QtGui.QAction(qicon("closeButton.png"),
"Close project", self)
self.actionCloseProj.triggered.connect(self.close)
self.actionCloseProj.setShortcut(self.tr("Ctrl+Shift+W"))
self.actionNewProj = QtGui.QAction(qicon("new.png"), "New Project",
self)
self.actionNewProj.triggered.connect(self.new_project)
self.actionNewProj.setShortcut(self.tr("Ctrl+Shift+N"))
self.actionOpenProj = QtGui.QAction(qicon("open.png"), "Open Project",
self)
self.actionOpenProj.triggered.connect(self.open_project)
self.actionOpenProj.setShortcut(self.tr('Ctrl+Shift+O'))
def main():
app = QtGui.QApplication(sys.argv)
project_manager = ProjectManager()
project_manager.discover()
scroll = ProjectSelectorScroll(project_manager.projects)
# Display
scroll.show()
app.exec_()
def main():
app = QtGui.QApplication(sys.argv)
project_manager = ProjectManager()
project_manager.discover()
scroll = ProjectSelectorScroll(project_manager.projects)
# Display
scroll.show()
app.exec_()
def __init__(self):
import traceback
traceback.print_stack(file=sys.__stdout__)
self._project = None
self._is_proj = False
self._debug = False
self.gui = True
self.tmpdir = path(get_openalea_tmp_dir())
self._config = MainConfig()
self.extension = None
self.applet = {}
self.manager = {}
self.package_manager = package_manager
self.control_manager = ControlManager()
self.project_manager = ProjectManager()
self.plugin_manager = PluginManager()
self.plugin_instance_manager = PluginInstanceManager()
self.manager['control'] = self.control_manager
self.manager['package'] = self.package_manager
self.manager['project'] = self.project_manager
self.manager['plugin'] = self.plugin_manager
self.manager['plugin_instance'] = self.plugin_instance_manager
self.world = World()
self.interpreter = interpreter()
# Hack if interpreter is an object from class TerminalInteractiveShell
if not hasattr(self.interpreter, "shell"):
self.interpreter.shell = self.interpreter
if hasattr(self.interpreter.shell, "events"):
self.interpreter.shell.events.register("post_execute",
self.add_to_history)
else:
print("You need ipython >= 2.0 to use history.")
# self.project_manager.set_shell(self.interpreter.shell)
self.interpreter.locals['session'] = self
self.old_syspath = sys.path
self.load_default()
self.__class__.instantiated = True
def __init__(self):
QtGui.QWidget.__init__(self)
AbstractListener.__init__(self)
layout = QtGui.QVBoxLayout(self)
self.view = ProjectManagerView()
self.model = self.view.model()
layout.addWidget(self.view)
layout.setContentsMargins(0, 0, 0, 0)
self.pm = ProjectManager()
self.menu_available_projects = QtGui.QMenu(u'Available Projects')
self.actionNewProj = self.view.actionNewProj
self.actionOpenProj = self.view.actionOpenProj
group = "Project"
self._actions = [[group, "Manage Project", self.view.actionNewProj, 0],
[group, "Manage Project", self.view.actionOpenProj, 0],
[group, "Manage Project", self.view.actionSaveProj, 0],
# [group, "Manage Project", self.view.actionSaveProjAs, 1],
[group, "Manage Project", self.view.actionCloseProj, 0],
# [group, "Manage Project", self.view.actionEditMeta, 1],
# ["Project", "Manage Project", self.actionRenameProject, 1],
]
self._actions += self.view._actions
# Menu used to display all available projects.
# This menu is filled dynamically each time this menu is opened
self.menu_available_projects = QtGui.QMenu(u'Available Projects')
self.menu_available_projects.aboutToShow.connect(self._update_available_project_menu)
self.action_available_project = {} # Dict used to know what project corresponds to triggered action
self.pm.register_listener(self)
def instantiate(self, call_stack=[]):
"""
Returns a node instance.
:param call_stack: the list of NodeFactory id already in call stack
(in order to avoir infinite recursion)
"""
from openalea.core.service.run import get_model
model = get_model(self.name)
if model is None:
print "error loading model ", self.name
# print "Available models are ", pm.cproject.model.keys()
# TODO
def signature(args_info, out=False):
args = []
if args_info:
for arg in args_info:
d = {}
d['name'] = arg.name
if arg.interface:
d['interface'] = arg.interface
if not out and arg.default is not None:
d['value'] = arg.default
if d:
args.append(d)
return args
# If class is not a Node, embed object in a Node class
if model:
# model.read()
self.inputs = signature(model.inputs_info)
self.outputs = signature(model.outputs_info, out=True)
if not self.outputs:
self.outputs = (dict(name="out", interface=None), )
node = ModelNode(model, self.inputs, self.outputs)
# Properties
try:
node.factory = self
node.lazy = self.lazy
if (not node.caption):
node.set_caption(self.name)
node.delay = self.delay
except:
pass
return node
else:
from openalea.core.project.manager import ProjectManager
pm = ProjectManager()
print "We can't instantiate node from project %s because we don't have model %s" % (
pm.cproject.name, self.name)
print "We only have models : "
print ", ".join(pm.cproject.model.keys())
def decode(mimetype, mimedata):
"""
decode("openalealab/model", "model1") -> Model("model1")
returns an object Model of model1
"""
if mimetype == 'openalealab/control':
from openalea.core.control.manager import ControlManager
identifier, name = mimedata.split(';')
control = ControlManager().control(name)
if isinstance(control, list):
return ControlManager().control(uid=identifier)
return control
elif mimetype == 'openalealab/data':
from openalea.core.project.manager import ProjectManager
from openalea.core.path import path
pm = ProjectManager()
return pm.get('data', path(mimedata).name)
else:
return str(mimedata)
def main():
from openalea.core.project.manager import ProjectManager
import sys
app = QtGui.QApplication(sys.argv)
tabwidget = QtGui.QTabWidget()
project_manager = ProjectManager()
project_manager.discover()
projects = project_manager.projects
for project in projects:
# Create widget
preview_widget = Preview(project)
tabwidget.addTab(preview_widget, project.name)
# Display
tabwidget.show()
app.exec_()
def main():
from openalea.core.project.manager import ProjectManager
import sys
app = QtGui.QApplication(sys.argv)
tabwidget = QtGui.QTabWidget()
project_manager = ProjectManager()
project_manager.discover()
projects = project_manager.projects
for project in projects:
# Create widget
preview_widget = Preview(project)
tabwidget.addTab(preview_widget, project.name)
# Display
tabwidget.show()
app.exec_()
def __init__(self):
QtGui.QWidget.__init__(self)
AbstractListener.__init__(self)
layout = QtGui.QVBoxLayout(self)
self.view = ProjectManagerView()
self.model = self.view.model()
layout.addWidget(self.view)
layout.setContentsMargins(0, 0, 0, 0)
self.pm = ProjectManager()
self.menu_available_projects = QtGui.QMenu(u'Available Projects')
self.actionNewProj = self.view.actionNewProj
self.actionOpenProj = self.view.actionOpenProj
group = "Project"
self._actions = [
[group, "Manage Project", self.view.actionNewProj, 0],
[group, "Manage Project", self.view.actionOpenProj, 0],
[group, "Manage Project", self.view.actionSaveProj, 0],
# [group, "Manage Project", self.view.actionSaveProjAs, 1],
[group, "Manage Project", self.view.actionCloseProj, 0],
# [group, "Manage Project", self.view.actionEditMeta, 1],
# ["Project", "Manage Project", self.actionRenameProject, 1],
]
self._actions += self.view._actions
# Menu used to display all available projects.
# This menu is filled dynamically each time this menu is opened
self.menu_available_projects = QtGui.QMenu(u'Available Projects')
self.menu_available_projects.aboutToShow.connect(
self._update_available_project_menu)
self.action_available_project = {
} # Dict used to know what project corresponds to triggered action
self.pm.register_listener(self)
def __init__(self):
import traceback
traceback.print_stack(file=sys.__stdout__)
self._project = None
self._is_proj = False
self._debug = False
self.gui = True
self.tmpdir = path(get_openalea_tmp_dir())
self._config = MainConfig()
self.extension = None
self.applet = {}
self.manager = {}
self.package_manager = package_manager
self.control_manager = ControlManager()
self.project_manager = ProjectManager()
self.plugin_manager = PluginManager()
self.plugin_instance_manager = PluginInstanceManager()
self.manager['control'] = self.control_manager
self.manager['package'] = self.package_manager
self.manager['project'] = self.project_manager
self.manager['plugin'] = self.plugin_manager
self.manager['plugin_instance'] = self.plugin_instance_manager
self.world = World()
self.interpreter = interpreter()
# Hack if interpreter is an object from class TerminalInteractiveShell
if not hasattr(self.interpreter, "shell"):
self.interpreter.shell = self.interpreter
if hasattr(self.interpreter.shell, "events"):
self.interpreter.shell.events.register("post_execute", self.add_to_history)
else:
print("You need ipython >= 2.0 to use history.")
# self.project_manager.set_shell(self.interpreter.shell)
self.interpreter.locals['session'] = self
self.old_syspath = sys.path
self.load_default()
self.__class__.instantiated = True
def __init__(self):
QtGui.QTreeView.__init__(self)
self._model = ProjectManagerModel()
self.pm = ProjectManager()
self.setModel(self._model)
self._model.dataChanged.connect(self._on_model_changed)
self.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
self.connect(self, QtCore.SIGNAL('doubleClicked(const QModelIndex&)'), self.open)
self.setHeaderHidden(True)
self.setDragEnabled(True)
self.setDropIndicatorShown(True)
self.setAcceptDrops(True)
self._actions = []
self._new_file_actions = {}
self.paradigms_actions = []
self.paradigms = {}
self.actionEditMeta = QtGui.QAction(qicon("book.png"), "Edit Project Information", self)
self.actionEditMeta.triggered.connect(self.edit_metadata)
self.actionImportFile = QtGui.QAction(qicon("open.png"), "Import file", self)
self.actionImportFile.triggered.connect(self.import_file)
self.actionSaveProjAs = QtGui.QAction(qicon("save.png"), "Save As", self)
self.actionSaveProjAs.triggered.connect(self.save_as)
self.actionSaveProj = QtGui.QAction(qicon("save.png"), "Save project", self)
self.actionSaveProj.triggered.connect(self.save)
self.actionSaveProj.setShortcut(
QtGui.QApplication.translate("MainWindow", "Ctrl+Shift+S", None, QtGui.QApplication.UnicodeUTF8))
self.actionCloseProj = QtGui.QAction(qicon("closeButton.png"), "Close project", self)
self.actionCloseProj.triggered.connect(self.close)
self.actionCloseProj.setShortcut(self.tr("Ctrl+Shift+W"))
self.actionNewProj = QtGui.QAction(qicon("new.png"), "New Project", self)
self.actionNewProj.triggered.connect(self.new_project)
self.actionNewProj.setShortcut(self.tr("Ctrl+Shift+N"))
self.actionOpenProj = QtGui.QAction(qicon("open.png"), "Open Project", self)
self.actionOpenProj.triggered.connect(self.open_project)
self.actionOpenProj.setShortcut(self.tr('Ctrl+Shift+O'))
def on_project_opened(self):
pm = ProjectManager()
pm.cproject = self.project
self.hide()
import shutil
import sys
from openalea.core.path import path as Path
from openalea.core.path import tempdir
from openalea.core.project.manager import ProjectManager
from openalea.core.project.project import Project, _normpath
from openalea.core.unittest_tools import TestCase, EventTracker
# used to test symlinks only on unix systems
win = 'win' in sys.platform
pm = ProjectManager()
pm.count = 0
ev = EventTracker()
# ev.debug = True
pm.register_listener(ev)
def get_data(filename):
return Path(__file__).parent.abspath() / 'data' / filename
class TestProjectManager(TestCase):
def setUp(self):
self.tmpdir = tempdir()
self.tmpdir2 = tempdir()
pm.clear()
# Force to ignore default repositories
from openalea.core.project import Project
from openalea.core.service.control import new_control
from openalea.core.service.model import ModelFactory
from openalea.oalab.service.paradigm import paradigm_controller
from openalea.core.service.ipython import interpreter
interp = interpreter()
interp.locals['interp'] = interp
pm = PackageManager()
project_manager = ProjectManager()
project = Project('unittest')
project_manager.cproject = project
if not project.started:
project.start()
interp.locals['project_manager'] = project_manager
interp.locals['project'] = project
def composite_node():
inputs = []
outputs = []
for io in list('abcd'):
inputs.append({'name': io, 'desc': 'Input %s' % io.upper(), 'value': 0})
outputs.append({'name': io, 'desc': 'Input %s' % io.upper()})
class ProjectManagerView(QtGui.QTreeView):
def __init__(self):
QtGui.QTreeView.__init__(self)
self._model = ProjectManagerModel()
self.pm = ProjectManager()
self.setModel(self._model)
self._model.dataChanged.connect(self._on_model_changed)
self.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
self.connect(self, QtCore.SIGNAL('doubleClicked(const QModelIndex&)'),
self.open)
self.setHeaderHidden(True)
self.setDragEnabled(True)
self.setDropIndicatorShown(True)
self.setAcceptDrops(True)
self._actions = []
self._new_file_actions = {}
self.paradigms_actions = []
self.paradigms = {}
self.actionEditMeta = QtGui.QAction(qicon("book.png"),
"Edit Project Information", self)
self.actionEditMeta.triggered.connect(self.edit_metadata)
self.actionImportFile = QtGui.QAction(qicon("open.png"), "Import file",
self)
self.actionImportFile.triggered.connect(self.import_file)
self.actionSaveProjAs = QtGui.QAction(qicon("save.png"), "Save As",
self)
self.actionSaveProjAs.triggered.connect(self.save_as)
self.actionSaveProj = QtGui.QAction(qicon("save.png"), "Save project",
self)
self.actionSaveProj.triggered.connect(self.save)
self.actionSaveProj.setShortcut(
QtGui.QApplication.translate("MainWindow", "Ctrl+Shift+S", None,
QtGui.QApplication.UnicodeUTF8))
self.actionCloseProj = QtGui.QAction(qicon("closeButton.png"),
"Close project", self)
self.actionCloseProj.triggered.connect(self.close)
self.actionCloseProj.setShortcut(self.tr("Ctrl+Shift+W"))
self.actionNewProj = QtGui.QAction(qicon("new.png"), "New Project",
self)
self.actionNewProj.triggered.connect(self.new_project)
self.actionNewProj.setShortcut(self.tr("Ctrl+Shift+N"))
self.actionOpenProj = QtGui.QAction(qicon("open.png"), "Open Project",
self)
self.actionOpenProj.triggered.connect(self.open_project)
self.actionOpenProj.setShortcut(self.tr('Ctrl+Shift+O'))
# API
def _get_paradigm_container(self):
if plugin_instance_exists('oalab.applet', 'EditorManager'):
return plugin_instance('oalab.applet', 'EditorManager')
paradigm_container = property(fget=_get_paradigm_container)
def initialize(self):
pass
def set_project(self, project):
# TODO: Dirty hack to remove asap. Close project selector if widget has been created
if hasattr(self, "proj_selector"):
del self.proj_selector
self._model.set_project(project)
if project:
self.close_all_scripts()
# self.open_all_scripts_from_project(project)
self.expandAll()
else:
self.close_all_scripts()
def refresh(self):
self._model.refresh()
# Convenience methods
def getItem(self):
index = self.getIndex()
if index:
return self._model.itemFromIndex(index)
def getIndex(self):
indices = self.selectedIndexes()
for index in indices:
return index
def project(self):
if self.pm:
return self.pm.cproject
def selected_data(self):
index = self.getIndex()
project = self.project()
data = self._model.projectdata(index)
if index is None or project is None or data is None:
return (None, None, None)
else:
category, name = data
return project, category, name
# Slots
def _on_model_changed(self):
self.expandAll()
# Contextual menu
def add_new_file_actions(self, menu):
for applet in self.paradigm_container.paradigms.values():
action = QtGui.QAction(qicon(applet.icon),
'New %s' % applet.default_name, self)
action.triggered.connect(self.new_file)
self._new_file_actions[action] = applet
menu.addAction(action)
menu.addSeparator()
def create_menu(self):
menu = QtGui.QMenu(self)
project, category, obj = self.selected_data()
if category == 'category' and obj == 'model':
self.add_new_file_actions(menu)
elif category == 'category' and obj == 'data':
import_data = QtGui.QAction(qicon('import.png'), 'Import data',
self)
import_data.triggered.connect(self.open)
menu.addAction(import_data)
elif category == 'category' and obj in ('startup', 'doc', 'lib'):
new_startup = QtGui.QAction(qicon('filenew.png'), 'New file', self)
new_startup.triggered.connect(self.new_file)
menu.addAction(new_startup)
if category == 'model':
self.add_new_file_actions(menu)
if category in ['model', 'src', 'startup', 'doc', 'data', 'lib']:
editAction = QtGui.QAction(qicon('open.png'), 'Open "%s"' % obj,
self)
menu.addAction(editAction)
editAction.triggered.connect(self.open)
rename = QtGui.QAction(qicon('Crystal_Clear_action_editcopy.png'),
'Rename', self)
rename.triggered.connect(self.rename)
menu.addAction(rename)
remove = QtGui.QAction(
qicon('Crystal_Clear_action_edit_remove.png'), 'Remove', self)
remove.triggered.connect(self.remove)
menu.addAction(remove)
menu.addSeparator()
deleteAction = QtGui.QAction(
qicon('Crystal_Clear_action_stop.png'), 'Delete', self)
menu.addAction(deleteAction)
deleteAction.triggered.connect(self.delete)
if category in ['project']:
menu.addAction(self.actionEditMeta)
menu.addAction(self.actionSaveProj)
menu.addAction(self.actionSaveProjAs)
menu.addAction(self.actionCloseProj)
return menu
def contextMenuEvent(self, event):
if self.pm.cproject is None:
return
menu = self.create_menu()
menu.exec_(event.globalPos())
# Action's slots
def edit_metadata(self):
project = self.project()
if project:
project_creator = CreateProjectWidget(project)
dialog = ModalDialog(project_creator)
if dialog.exec_():
_proj = project_creator.project()
if _proj.name != project.name or _proj.projectdir != project.projectdir:
project.move(_proj.path)
project.metadata = project_creator.metadata()
project.save()
def open_project(self, name=False, path=None):
"""
If name==false, display a widget to choose project to open.
Then open project.
"""
self.pm.discover()
projects = self.pm.projects
self.proj_selector = ProjectSelectorScroll(projects=projects)
self.proj_selector.setAttribute(QtCore.Qt.WA_DeleteOnClose)
self.proj_selector.show()
def new_project(self):
project_creator = CreateProjectWidget()
dialog = ModalDialog(project_creator)
if dialog.exec_():
project = project_creator.project()
self.pm.cproject = project
def open_all_scripts_from_project(self, project):
if self.paradigm_container is not None:
for model in project.model.values():
self.paradigm_container.open_data(model)
def new_file(self, dtype=None):
try:
applet = self._new_file_actions[self.sender()]
except KeyError:
dtype = None
else:
dtype = applet.default_name
project, category, data = self.selected_data()
code = ''
project = self.project()
if category == 'category':
category = data
elif category in project.DEFAULT_CATEGORIES:
pass
else:
category = None
if dtype is None and category in ['startup', 'lib']:
dtype = 'Python'
if category in ['startup', 'lib']:
d = {'startup': 'start.py', 'lib': 'algo.py'}
name = d[category]
elif dtype:
klass = DataClass(MimeType(name=dtype))
name = '%s_%s.%s' % (klass.default_name, category, klass.extension)
else:
name = category
category, data = self.paradigm_container.add(project,
name,
code,
dtype=dtype,
category=category)
if data:
self.paradigm_container.open_data(data)
def open(self):
project, category, name = self.selected_data()
if project:
if category == 'category' and name == 'data':
p = QtGui.QFileDialog.getOpenFileName(self,
'Select File to open',
project.path, "All (*)")
if p:
p = path(p)
project.add(name, path=p)
elif category == 'category':
pass
elif category == 'project':
pass
# self.open_all_scripts_from_project(project)
elif category == 'data':
from openalea.file.files import start
start(project.get(category, name).path)
else:
self.paradigm_container.open_data(project.get(category, name))
def _rename(self, project, category, name):
if category in project.DEFAULT_CATEGORIES:
filelist = getattr(project, category).keys()
renamer = RenameModel(filelist, name)
dialog = ModalDialog(renamer)
if dialog.exec_():
old_name = renamer.old_name()
new_name = renamer.new_name()
project.rename_item(category, old_name, new_name)
elif category == 'project':
self.edit_metadata()
def rename(self):
project, category, name = self.selected_data()
if project:
self._rename(project, category, name)
def remove(self):
project, category, name = self.selected_data()
if project:
project.remove(category, filename=name)
def delete(self):
project, category, name = self.selected_data()
if project:
if category in project.DEFAULT_CATEGORIES:
data = project.get(category, name)
confirm = QtGui.QLabel('Remove %s ?' % data.path)
dialog = ModalDialog(confirm)
if dialog.exec_():
project.remove(category, data)
data.path.remove()
if self.paradigm_container:
self.paradigm_container.close_data(data)
def save(self):
project = self.project()
if project:
project.save()
if self.paradigm_container:
self.paradigm_container.save_all()
def save_as(self):
project = self.project()
if project:
p = path(
self.showNewProjectDialog(
default_name=None,
text="Select name to save project")).abspath()
projectdir, name = p.splitpath()
if name:
project.save_as(projectdir, name)
def close(self):
self.pm.cproject = None
def close_all_scripts(self):
if self.paradigm_container is None:
return
self.paradigm_container.closeAll()
def import_file(self):
print 'import_file'
def showNewProjectDialog(self, default_name=None, text=None, parent=None):
my_path = path(settings.get_project_dir())
if default_name:
my_path = my_path / default_name
if not text:
text = 'Select name to create project'
fname = QtGui.QFileDialog.getSaveFileName(parent, text, my_path)
return fname
def showOpenProjectDialog(self, parent=None):
my_path = path(settings.get_project_dir())
fname = QtGui.QFileDialog.getExistingDirectory(
parent, 'Select Project Directory', my_path)
return fname
# Drag and drop
def startDrag(self, supportedActions):
index = self.getIndex()
item = self.getItem()
data = self._model.projectdata(index)
if data is None:
return
category, name = data
# Check item in src
# TODO move this part in dragEnterEvent with mimetype
obj = self._model._project.get(category, name)
if category in ['src', 'model']:
# Read file and parse model to get inputs, outputs, doc that may be
# useful once dropped.
obj.read()
text = item.text()
# name_without_ext = ".".join(text.split(".")[:-1])
name_without_ext = text
name_without_space = "_".join(name_without_ext.split())
for sym in ["-", "+", "*", "/", "\"", "."]:
name_without_space = "_".join(name_without_space.split(sym))
python_call_string = '%s = Model("%s")' % (name_without_space,
name_without_ext)
icon = item.icon()
pixmap = icon.pixmap(20, 20)
itemData = QtCore.QByteArray()
dataStream = QtCore.QDataStream(itemData,
QtCore.QIODevice.WriteOnly)
model_id = name_without_ext
dataStream.writeString(str(python_call_string))
dataStream.writeString(str(model_id))
mimeData = QtCore.QMimeData()
mimeData.setText(python_call_string)
mimeData.setData("openalealab/model", itemData)
drag = QtGui.QDrag(self)
drag.setMimeData(mimeData)
drag.setHotSpot(
QtCore.QPoint(pixmap.width() / 2,
pixmap.height() / 2))
drag.setPixmap(pixmap)
drag.start(QtCore.Qt.CopyAction)
elif category == 'data':
p = '%s/%r' % (category, str(obj.filename))
mimetype, mimedata = encode(obj, mimetype='openalealab/data')
qmime_data = QtCore.QMimeData()
qmime_data.setData(mimetype, mimedata)
qmime_data.setText(p)
drag = QtGui.QDrag(self)
drag.setMimeData(qmime_data)
drag.start()
def dragEnterEvent(self, event):
if event.mimeData().hasFormat("openalealab/model"):
event.accept()
else:
event.ignore()
def dragMoveEvent(self, event):
if event.mimeData().hasFormat("openalealab/model"):
event.setDropAction(QtCore.Qt.MoveAction)
event.accept()
else:
event.ignore()
def dropEvent(self, event):
event.ignore()
def new_tmp_project(projectdir):
pm = ProjectManager()
project = pm.create('tmpproject', projectdir=projectdir)
pm.cproject = project
return project
# Copyright 2015 INRIA - CIRAD - INRA
#
# File author(s): Guillaume Baty <*****@*****.**>
#
# File contributor(s):
#
# Distributed under the Cecill-C License.
# See accompanying file LICENSE.txt or copy at
# http://www.cecill.info/licences/Licence_CeCILL-C_V1-en.html
#
# OpenAlea WebSite : http://openalea.gforge.inria.fr
#
###############################################################################
from openalea.core.project.manager import ProjectManager
PM = ProjectManager()
def set_active_project(project):
PM.cproject = project
def active_project():
return PM.cproject
def projects():
PM.discover()
return list(PM.items())
def refresh_project_list(self):
project_manager = ProjectManager()
project_manager.discover()
self.projects = project_manager.projects
self.init()
for proj in projects:
print 'load', proj
pm.cproject = proj
if __name__ == '__main__':
tmp = tempdir()
instance = QtGui.QApplication.instance()
if instance is None:
app = QtGui.QApplication([])
else:
app = instance
session = Session()
pm = ProjectManager()
pm.discover()
pmw = ProjectManagerWidget()
pmw.initialize()
# pm.load('mtg')
from openalea.oalab.shell import get_shell_class
from openalea.core.service.ipython import interpreter as interpreter_
# Set interpreter
interpreter = interpreter_()
interpreter.user_ns['interp'] = interpreter
interpreter.user_ns.update(locals())
interpreter.user_ns['pmw'] = pmw
interpreter.user_ns['pm'] = pm
# Set Shell Widget
import unittest
from openalea.core.unittest_tools import TestCase, EventTracker
from openalea.core.path import tempdir
from openalea.core.path import path as Path
from openalea.core.project.project import Project
from openalea.core.project.manager import ProjectManager
pm = ProjectManager()
ev = EventTracker()
# ev.debug = True
pm.register_listener(ev)
def get_data(filename):
return Path(__file__).parent.abspath() / 'data' / filename
class TestProjectManager(TestCase):
def setUp(self):
self.tmpdir = tempdir()
self.tmpdir2 = tempdir()
pm.clear()
# Force to ignore default repositories
pm.repositories = [self.tmpdir]
ev.events # clear events
def tearDown(self):
self.tmpdir.rmtree()
def on_project_opened(self):
pm = ProjectManager()
pm.cproject = self.project
self.hide()
def refresh_project_list(self):
project_manager = ProjectManager()
project_manager.discover()
self.projects = project_manager.projects
self.init()
import copy
from openalea.core.control.manager import ControlManager
from openalea.core.project.manager import ProjectManager
from openalea.core.service.model import to_model
cm = ControlManager()
pm = ProjectManager()
def get_model(name):
data = pm.cproject.get_model(name)
if data:
model = to_model(data)
if model:
return copy.copy(model)
def namespace():
# Move to runner class (model manager or ParadigmEditor)
namespace = {}
namespace.update(cm.namespace())
namespace.update(pm.cproject.ns)
namespace['Model'] = get_model
return namespace
import shutil
import sys
from openalea.core.path import path as Path
from openalea.core.path import tempdir
from openalea.core.project.manager import ProjectManager
from openalea.core.project.project import Project
from openalea.core.unittest_tools import TestCase, EventTracker
# used to test symlinks only on unix systems
win = 'win' in sys.platform
pm = ProjectManager()
pm.count = 0
ev = EventTracker()
# ev.debug = True
pm.register_listener(ev)
def get_data(filename):
return Path(__file__).parent.abspath() / 'data' / filename
class TestProjectManager(TestCase):
def setUp(self):
self.tmpdir = tempdir()
self.tmpdir2 = tempdir()
from openalea.core.pkgmanager import PackageManager
from openalea.core.project.manager import ProjectManager
from openalea.core.project import Project
from openalea.core.service.control import new_control
from openalea.core.service.model import ModelFactory
from openalea.oalab.service.paradigm import paradigm_controller
from openalea.core.service.ipython import interpreter
interp = interpreter()
interp.locals['interp'] = interp
pm = PackageManager()
project_manager = ProjectManager()
project = Project('unittest')
project_manager.cproject = project
if not project.started:
project.start()
interp.locals['project_manager'] = project_manager
interp.locals['project'] = project
def composite_node():
inputs = []
outputs = []
for io in list('abcd'):
inputs.append({
'name': io,
'desc': 'Input %s' % io.upper(),
class ProjectManagerWidget(QtGui.QWidget, AbstractListener):
def __init__(self):
QtGui.QWidget.__init__(self)
AbstractListener.__init__(self)
layout = QtGui.QVBoxLayout(self)
self.view = ProjectManagerView()
self.model = self.view.model()
layout.addWidget(self.view)
layout.setContentsMargins(0, 0, 0, 0)
self.pm = ProjectManager()
self.menu_available_projects = QtGui.QMenu(u'Available Projects')
self.actionNewProj = self.view.actionNewProj
self.actionOpenProj = self.view.actionOpenProj
group = "Project"
self._actions = [[group, "Manage Project", self.view.actionNewProj, 0],
[group, "Manage Project", self.view.actionOpenProj, 0],
[group, "Manage Project", self.view.actionSaveProj, 0],
# [group, "Manage Project", self.view.actionSaveProjAs, 1],
[group, "Manage Project", self.view.actionCloseProj, 0],
# [group, "Manage Project", self.view.actionEditMeta, 1],
# ["Project", "Manage Project", self.actionRenameProject, 1],
]
self._actions += self.view._actions
# Menu used to display all available projects.
# This menu is filled dynamically each time this menu is opened
self.menu_available_projects = QtGui.QMenu(u'Available Projects')
self.menu_available_projects.aboutToShow.connect(self._update_available_project_menu)
self.action_available_project = {} # Dict used to know what project corresponds to triggered action
self.pm.register_listener(self)
def initialize(self):
self.view.initialize()
self.pm.load_default()
self.set_project(self.pm.cproject)
def closeEvent(self, event):
self.writeSettings()
event.accept()
def actions(self):
return self._actions
def toolbar_actions(self):
return [
["Project", "Manage", self.view.actionNewProj, 0],
["Project", "Manage", self.view.actionOpenProj, 0],
["Project", "Manage", self.view.actionSaveProj, 0],
["Project", "Manage", self.view.actionCloseProj, 0],
["Project", "Manage", self.view.actionSaveProjAs, 1],
["Project", "Manage", self.view.actionEditMeta, 1],
]
def menus(self):
actions = [action[2] for action in self.toolbar_actions()]
menu = QtGui.QMenu('File', self)
menu.addActions(actions)
menu.addSeparator()
menu.addMenu(self.menu_available_projects)
return [menu]
def project(self):
if self.pm:
return self.pm.cproject
def _update_available_project_menu(self):
"""
Discover all projects and generate an action for each one.
Then connect this action to _on_open_project_triggered
"""
self.pm.discover()
self.menu_available_projects.clear()
self.action_available_project.clear()
all_projects = {} # dict parent dir -> list of Project objects
for project in self.pm.projects:
all_projects.setdefault(project.projectdir, []).append(project)
for projectdir, projects in all_projects.iteritems():
title = unicode(projectdir.name)
if title == 'data':
title = 'Examples'
menu = QtGui.QMenu(title, self.menu_available_projects)
for project in projects:
icon_path = project.icon_path
icon_name = icon_path if icon_path else ":/images/resources/openalealogo.png"
action = QtGui.QAction(QtGui.QIcon(icon_name), project.name, self.menu_available_projects)
action.triggered.connect(self._on_open_project_triggered)
menu.addAction(action)
self.action_available_project[action] = project
self.menu_available_projects.addMenu(menu)
return self.menu_available_projects
def _on_open_project_triggered(self):
project = self.action_available_project[self.sender()]
self.pm.cproject = project
def notify(self, sender, event=None):
signal, data = event
if signal == 'project_changed':
project = self.pm.cproject
self.view.set_project(project=project)
elif signal == 'project_updated':
self.view.refresh()
def set_project(self, project):
self.view.set_project(project)
####################################################################
# Settings
####################################################################
def writeSettings(self):
"""
Register current settings (geometry and window state)
in a setting file
"""
if self.pm.cproject:
from openalea.core.settings import Settings
last_proj = self.pm.cproject.name
config = Settings()
config.set("ProjectManager", "Last Project", last_proj)
config.write()
class Session(object):
"""
Session is a non graphical class that centralize managers for ...
- application settings (:class:`~openalea.oalab.config.main.MainConfig`)
- projects (:class:`~openalea.oalab.project.manager.ProjectManager`)
- world (:class:`~openalea.oalab.world.world.World`)
- interpreter (see :mod:`~openalea.vpltk.shell.shell`)
"""
__metaclass__ = Singleton
instantiated = False
def __init__(self):
import traceback
traceback.print_stack(file=sys.__stdout__)
self._project = None
self._is_proj = False
self._debug = False
self.gui = True
self.tmpdir = path(get_openalea_tmp_dir())
self._config = MainConfig()
self.extension = None
self.applet = {}
self.manager = {}
self.package_manager = package_manager
self.control_manager = ControlManager()
self.project_manager = ProjectManager()
self.plugin_manager = PluginManager()
self.plugin_instance_manager = PluginInstanceManager()
self.manager['control'] = self.control_manager
self.manager['package'] = self.package_manager
self.manager['project'] = self.project_manager
self.manager['plugin'] = self.plugin_manager
self.manager['plugin_instance'] = self.plugin_instance_manager
self.world = World()
self.interpreter = interpreter()
# Hack if interpreter is an object from class TerminalInteractiveShell
if not hasattr(self.interpreter, "shell"):
self.interpreter.shell = self.interpreter
if hasattr(self.interpreter.shell, "events"):
self.interpreter.shell.events.register("post_execute", self.add_to_history)
else:
print("You need ipython >= 2.0 to use history.")
# self.project_manager.set_shell(self.interpreter.shell)
self.interpreter.locals['session'] = self
self.old_syspath = sys.path
self.load_default()
self.__class__.instantiated = True
@property
def project(self):
"""
:return: current project if one is opened. Else return None.
"""
return self.project_manager.cproject
def load_config_file(self, filename, path=None):
self._config.load_config_file(filename=filename, path=path)
def clear(self):
self.world.clear()
self.control_manager.clear()
def load_default(self):
self.project_manager.load_default()
self.update_namespace()
def update_namespace(self):
"""
Definition: Update namespace
"""
self.interpreter.locals['world'] = self.world
self.interpreter.locals['get_control'] = self.control_manager.control
self.interpreter.locals['follow'] = self.control_manager.register_follower
self.interpreter.locals['unfollow'] = self.control_manager.unregister_follower
if self.project:
if self.project.path.exists():
os.chdir(self.project.path)
sys.path.insert(0, str(self.project.path / 'lib'))
else:
os.chdir(self.tmpdir)
sys.path.insert(0, str(self.tmpdir / 'lib'))
self.interpreter.locals.update(self.project.ns)
self.interpreter.locals['project'] = self.project
self.interpreter.locals['Model'] = get_model
self.interpreter.locals['data'] = self.project.path / 'data'
else:
# close
sys.path = self.old_syspath
def add_to_history(self, *args, **kwargs):
"""
Send the last sent of history to the components that display history
"""
from openalea.oalab.service.history import display_history
records = self.interpreter.shell.history_manager.get_range()
input_ = ''
# loop all elements in iterator to get last one.
# TODO: search method returning directly last input
for session, line, input_ in records:
pass
display_history(input_)
config = property(fget=lambda self: self._config.config)
@property
def debug_plugins(self):
return self.plugin_manager.debug
@property
def debug(self):
return self._debug
@debug.setter
def debug(self, enable):
"""
If True, add some objects useful for debug in shell namespace:
- applet: dict containing weak references to all applets
- manager: dict containing all managers
"""
self._debug = enable
env = self.interpreter.locals
if self._debug is True:
env['manager'] = self.manager
env['applet'] = self.applet
else:
for varname in ('applet', 'manager'):
if varname in env:
del env[varname]
class ProjectManagerView(QtGui.QTreeView):
def __init__(self):
QtGui.QTreeView.__init__(self)
self._model = ProjectManagerModel()
self.pm = ProjectManager()
self.setModel(self._model)
self._model.dataChanged.connect(self._on_model_changed)
self.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
self.connect(self, QtCore.SIGNAL('doubleClicked(const QModelIndex&)'), self.open)
self.setHeaderHidden(True)
self.setDragEnabled(True)
self.setDropIndicatorShown(True)
self.setAcceptDrops(True)
self._actions = []
self._new_file_actions = {}
self.paradigms_actions = []
self.paradigms = {}
self.actionEditMeta = QtGui.QAction(qicon("book.png"), "Edit Project Information", self)
self.actionEditMeta.triggered.connect(self.edit_metadata)
self.actionImportFile = QtGui.QAction(qicon("open.png"), "Import file", self)
self.actionImportFile.triggered.connect(self.import_file)
self.actionSaveProjAs = QtGui.QAction(qicon("save.png"), "Save As", self)
self.actionSaveProjAs.triggered.connect(self.save_as)
self.actionSaveProj = QtGui.QAction(qicon("save.png"), "Save project", self)
self.actionSaveProj.triggered.connect(self.save)
self.actionSaveProj.setShortcut(
QtGui.QApplication.translate("MainWindow", "Ctrl+Shift+S", None, QtGui.QApplication.UnicodeUTF8))
self.actionCloseProj = QtGui.QAction(qicon("closeButton.png"), "Close project", self)
self.actionCloseProj.triggered.connect(self.close)
self.actionCloseProj.setShortcut(self.tr("Ctrl+Shift+W"))
self.actionNewProj = QtGui.QAction(qicon("new.png"), "New Project", self)
self.actionNewProj.triggered.connect(self.new_project)
self.actionNewProj.setShortcut(self.tr("Ctrl+Shift+N"))
self.actionOpenProj = QtGui.QAction(qicon("open.png"), "Open Project", self)
self.actionOpenProj.triggered.connect(self.open_project)
self.actionOpenProj.setShortcut(self.tr('Ctrl+Shift+O'))
# API
def _get_paradigm_container(self):
if plugin_instance_exists('oalab.applet', 'EditorManager'):
return plugin_instance('oalab.applet', 'EditorManager')
paradigm_container = property(fget=_get_paradigm_container)
def initialize(self):
pass
def set_project(self, project):
# TODO: Dirty hack to remove asap. Close project selector if widget has been created
if hasattr(self, "proj_selector"):
del self.proj_selector
self._model.set_project(project)
if project:
self.close_all_scripts()
# self.open_all_scripts_from_project(project)
self.expandAll()
else:
self.close_all_scripts()
def refresh(self):
self._model.refresh()
# Convenience methods
def getItem(self):
index = self.getIndex()
if index:
return self._model.itemFromIndex(index)
def getIndex(self):
indices = self.selectedIndexes()
for index in indices:
return index
def project(self):
if self.pm:
return self.pm.cproject
def selected_data(self):
index = self.getIndex()
project = self.project()
data = self._model.projectdata(index)
if index is None or project is None or data is None:
return (None, None, None)
else:
category, name = data
return project, category, name
# Slots
def _on_model_changed(self):
self.expandAll()
# Contextual menu
def add_new_file_actions(self, menu):
for applet in self.paradigm_container.paradigms.values():
action = QtGui.QAction(qicon(applet.icon), 'New %s' % applet.default_name, self)
action.triggered.connect(self.new_file)
self._new_file_actions[action] = applet
menu.addAction(action)
menu.addSeparator()
def create_menu(self):
menu = QtGui.QMenu(self)
project, category, obj = self.selected_data()
if category == 'category' and obj == 'model':
self.add_new_file_actions(menu)
elif category == 'category' and obj == 'data':
import_data = QtGui.QAction(qicon('import.png'), 'Import data', self)
import_data.triggered.connect(self.open)
menu.addAction(import_data)
elif category == 'category' and obj in ('startup', 'doc', 'lib'):
new_startup = QtGui.QAction(qicon('filenew.png'), 'New file', self)
new_startup.triggered.connect(self.new_file)
menu.addAction(new_startup)
if category == 'model':
self.add_new_file_actions(menu)
if category in ['model', 'src', 'startup', 'doc', 'data', 'lib']:
editAction = QtGui.QAction(qicon('open.png'), 'Open "%s"' % obj, self)
menu.addAction(editAction)
editAction.triggered.connect(self.open)
rename = QtGui.QAction(qicon('Crystal_Clear_action_editcopy.png'), 'Rename', self)
rename.triggered.connect(self.rename)
menu.addAction(rename)
remove = QtGui.QAction(qicon('Crystal_Clear_action_edit_remove.png'), 'Remove', self)
remove.triggered.connect(self.remove)
menu.addAction(remove)
menu.addSeparator()
deleteAction = QtGui.QAction(qicon('Crystal_Clear_action_stop.png'), 'Delete', self)
menu.addAction(deleteAction)
deleteAction.triggered.connect(self.delete)
if category in ['project']:
menu.addAction(self.actionEditMeta)
menu.addAction(self.actionSaveProj)
menu.addAction(self.actionSaveProjAs)
menu.addAction(self.actionCloseProj)
return menu
def contextMenuEvent(self, event):
if self.pm.cproject is None:
return
menu = self.create_menu()
menu.exec_(event.globalPos())
# Action's slots
def edit_metadata(self):
project = self.project()
if project:
project_creator = CreateProjectWidget(project)
dialog = ModalDialog(project_creator)
if dialog.exec_():
_proj = project_creator.project()
if _proj.name != project.name or _proj.projectdir != project.projectdir:
project.move(_proj.path)
project.metadata = project_creator.metadata()
project.save()
def open_project(self, name=False, path=None):
"""
If name==false, display a widget to choose project to open.
Then open project.
"""
self.pm.discover()
projects = self.pm.projects
self.proj_selector = ProjectSelectorScroll(projects=projects)
self.proj_selector.setAttribute(QtCore.Qt.WA_DeleteOnClose)
self.proj_selector.show()
def new_project(self):
project_creator = CreateProjectWidget()
dialog = ModalDialog(project_creator)
if dialog.exec_():
project = project_creator.project()
self.pm.cproject = project
def open_all_scripts_from_project(self, project):
if self.paradigm_container is not None:
for model in project.model.values():
self.paradigm_container.open_data(model)
def new_file(self, dtype=None):
try:
applet = self._new_file_actions[self.sender()]
except KeyError:
dtype = None
else:
dtype = applet.default_name
project, category, data = self.selected_data()
code = ''
project = self.project()
if category == 'category':
category = data
elif category in project.DEFAULT_CATEGORIES:
pass
else:
category = None
if dtype is None and category in ['startup', 'lib']:
dtype = 'Python'
if category in ['startup', 'lib']:
d = {'startup': 'start.py', 'lib': 'algo.py'}
name = d[category]
elif dtype:
klass = DataClass(MimeType(name=dtype))
name = '%s_%s.%s' % (klass.default_name, category, klass.extension)
else:
name = category
category, data = self.paradigm_container.add(project, name, code, dtype=dtype, category=category)
if data:
self.paradigm_container.open_data(data)
def open(self):
project, category, name = self.selected_data()
if project:
if category == 'category' and name == 'data':
p = QtGui.QFileDialog.getOpenFileName(self, 'Select File to open', project.path, "All (*)")
if p:
p = path(p)
project.add(name, path=p)
elif category == 'category':
pass
elif category == 'project':
pass
# self.open_all_scripts_from_project(project)
elif category == 'data':
from openalea.file.files import start
start(project.get(category, name).path)
else:
self.paradigm_container.open_data(project.get(category, name))
def _rename(self, project, category, name):
if category in project.DEFAULT_CATEGORIES:
filelist = getattr(project, category).keys()
renamer = RenameModel(filelist, name)
dialog = ModalDialog(renamer)
if dialog.exec_():
old_name = renamer.old_name()
new_name = renamer.new_name()
project.rename_item(category, old_name, new_name)
elif category == 'project':
self.edit_metadata()
def rename(self):
project, category, name = self.selected_data()
if project:
self._rename(project, category, name)
def remove(self):
project, category, name = self.selected_data()
if project:
project.remove(category, filename=name)
def delete(self):
project, category, name = self.selected_data()
if project:
if category in project.DEFAULT_CATEGORIES:
data = project.get(category, name)
confirm = QtGui.QLabel('Remove %s ?' % data.path)
dialog = ModalDialog(confirm)
if dialog.exec_():
project.remove(category, data)
data.path.remove()
if self.paradigm_container:
self.paradigm_container.close_data(data)
def save(self):
project = self.project()
if project:
project.save()
if self.paradigm_container:
self.paradigm_container.save_all()
def save_as(self):
project = self.project()
if project:
p = path(self.showNewProjectDialog(default_name=None, text="Select name to save project")).abspath()
projectdir, name = p.splitpath()
if name:
project.save_as(projectdir, name)
def close(self):
self.pm.cproject = None
def close_all_scripts(self):
if self.paradigm_container is None:
return
self.paradigm_container.closeAll()
def import_file(self):
print 'import_file'
def showNewProjectDialog(self, default_name=None, text=None, parent=None):
my_path = path(settings.get_project_dir())
if default_name:
my_path = my_path / default_name
if not text:
text = 'Select name to create project'
fname = QtGui.QFileDialog.getSaveFileName(parent, text, my_path)
return fname
def showOpenProjectDialog(self, parent=None):
my_path = path(settings.get_project_dir())
fname = QtGui.QFileDialog.getExistingDirectory(parent, 'Select Project Directory', my_path)
return fname
# Drag and drop
def startDrag(self, supportedActions):
index = self.getIndex()
item = self.getItem()
data = self._model.projectdata(index)
if data is None:
return
category, name = data
# Check item in src
# TODO move this part in dragEnterEvent with mimetype
obj = self._model._project.get(category, name)
if category in ['src', 'model']:
# Read file and parse model to get inputs, outputs, doc that may be
# useful once dropped.
obj.read()
text = item.text()
# name_without_ext = ".".join(text.split(".")[:-1])
name_without_ext = text
name_without_space = "_".join(name_without_ext.split())
for sym in ["-", "+", "*", "/", "\"", "."]:
name_without_space = "_".join(name_without_space.split(sym))
python_call_string = '%s = Model("%s")' % (name_without_space, name_without_ext)
icon = item.icon()
pixmap = icon.pixmap(20, 20)
itemData = QtCore.QByteArray()
dataStream = QtCore.QDataStream(itemData, QtCore.QIODevice.WriteOnly)
model_id = name_without_ext
dataStream.writeString(str(python_call_string))
dataStream.writeString(str(model_id))
mimeData = QtCore.QMimeData()
mimeData.setText(python_call_string)
mimeData.setData("openalealab/model", itemData)
drag = QtGui.QDrag(self)
drag.setMimeData(mimeData)
drag.setHotSpot(QtCore.QPoint(pixmap.width() / 2, pixmap.height() / 2))
drag.setPixmap(pixmap)
drag.start(QtCore.Qt.CopyAction)
elif category == 'data':
p = '%s/%r' % (category, str(obj.filename))
mimetype, mimedata = encode(obj, mimetype='openalealab/data')
qmime_data = QtCore.QMimeData()
qmime_data.setData(mimetype, mimedata)
qmime_data.setText(p)
drag = QtGui.QDrag(self)
drag.setMimeData(qmime_data)
drag.start()
def dragEnterEvent(self, event):
if event.mimeData().hasFormat("openalealab/model"):
event.accept()
else:
event.ignore()
def dragMoveEvent(self, event):
if event.mimeData().hasFormat("openalealab/model"):
event.setDropAction(QtCore.Qt.MoveAction)
event.accept()
else:
event.ignore()
def dropEvent(self, event):
event.ignore()
class ProjectManagerWidget(QtGui.QWidget, AbstractListener):
def __init__(self):
QtGui.QWidget.__init__(self)
AbstractListener.__init__(self)
layout = QtGui.QVBoxLayout(self)
self.view = ProjectManagerView()
self.model = self.view.model()
layout.addWidget(self.view)
layout.setContentsMargins(0, 0, 0, 0)
self.pm = ProjectManager()
self.menu_available_projects = QtGui.QMenu(u'Available Projects')
self.actionNewProj = self.view.actionNewProj
self.actionOpenProj = self.view.actionOpenProj
group = "Project"
self._actions = [
[group, "Manage Project", self.view.actionNewProj, 0],
[group, "Manage Project", self.view.actionOpenProj, 0],
[group, "Manage Project", self.view.actionSaveProj, 0],
# [group, "Manage Project", self.view.actionSaveProjAs, 1],
[group, "Manage Project", self.view.actionCloseProj, 0],
# [group, "Manage Project", self.view.actionEditMeta, 1],
# ["Project", "Manage Project", self.actionRenameProject, 1],
]
self._actions += self.view._actions
# Menu used to display all available projects.
# This menu is filled dynamically each time this menu is opened
self.menu_available_projects = QtGui.QMenu(u'Available Projects')
self.menu_available_projects.aboutToShow.connect(
self._update_available_project_menu)
self.action_available_project = {
} # Dict used to know what project corresponds to triggered action
self.pm.register_listener(self)
def initialize(self):
self.view.initialize()
self.pm.load_default()
self.set_project(self.pm.cproject)
def closeEvent(self, event):
self.writeSettings()
event.accept()
def actions(self):
return self._actions
def toolbar_actions(self):
return [
["Project", "Manage", self.view.actionNewProj, 0],
["Project", "Manage", self.view.actionOpenProj, 0],
["Project", "Manage", self.view.actionSaveProj, 0],
["Project", "Manage", self.view.actionCloseProj, 0],
["Project", "Manage", self.view.actionSaveProjAs, 1],
["Project", "Manage", self.view.actionEditMeta, 1],
]
def menus(self):
actions = [action[2] for action in self.toolbar_actions()]
menu = QtGui.QMenu('File', self)
menu.addActions(actions)
menu.addSeparator()
menu.addMenu(self.menu_available_projects)
return [menu]
def project(self):
if self.pm:
return self.pm.cproject
def _update_available_project_menu(self):
"""
Discover all projects and generate an action for each one.
Then connect this action to _on_open_project_triggered
"""
self.pm.discover()
self.menu_available_projects.clear()
self.action_available_project.clear()
all_projects = {} # dict parent dir -> list of Project objects
for project in self.pm.projects:
all_projects.setdefault(project.projectdir, []).append(project)
for projectdir, projects in all_projects.iteritems():
title = unicode(projectdir.name)
if title == 'data':
title = 'Examples'
menu = QtGui.QMenu(title, self.menu_available_projects)
for project in projects:
icon_path = project.icon_path
icon_name = icon_path if icon_path else ":/images/resources/openalealogo.png"
action = QtGui.QAction(QtGui.QIcon(icon_name), project.name,
self.menu_available_projects)
action.triggered.connect(self._on_open_project_triggered)
menu.addAction(action)
self.action_available_project[action] = project
self.menu_available_projects.addMenu(menu)
return self.menu_available_projects
def _on_open_project_triggered(self):
project = self.action_available_project[self.sender()]
self.pm.cproject = project
def notify(self, sender, event=None):
signal, data = event
if signal == 'project_changed':
project = self.pm.cproject
self.view.set_project(project=project)
elif signal == 'project_updated':
self.view.refresh()
def set_project(self, project):
self.view.set_project(project)
####################################################################
# Settings
####################################################################
def writeSettings(self):
"""
Register current settings (geometry and window state)
in a setting file
"""
if self.pm.cproject:
from openalea.core.settings import Settings
last_proj = self.pm.cproject.name
config = Settings()
config.set("ProjectManager", "Last Project", last_proj)
config.write()
from openalea.oalab.model.parse import InputObj, OutputObj
from openalea.core.model import Model
from openalea.core.service.run import namespace
from openalea.core.service.control import clear_controls
from openalea.core.project.manager import ProjectManager
import copy
pm = ProjectManager()
project = pm.create('unittest', '/tmp/notwritable')
pm.cproject = project
def register_model(model):
project.add('model', model)
def test_copy():
m = Model(name='m1')
m.set_step_code('c=a+b')
m.inputs_info = [InputObj('a'), InputObj('b')]
m.outputs_info = [OutputObj('c')]
m2 = copy.copy(m)
assert m is not m2
assert m.step_code == m2.step_code
assert [inp.name for inp in m2.inputs_info] == ['a', 'b']
assert [out.name for out in m2.outputs_info] == ['c']
def test_output():
class Session(object):
"""
Session is a non graphical class that centralize managers for ...
- application settings (:class:`~openalea.oalab.config.main.MainConfig`)
- projects (:class:`~openalea.oalab.project.manager.ProjectManager`)
- world (:class:`~openalea.oalab.world.world.World`)
- interpreter (see :mod:`~openalea.vpltk.shell.shell`)
"""
__metaclass__ = Singleton
instantiated = False
def __init__(self):
import traceback
traceback.print_stack(file=sys.__stdout__)
self._project = None
self._is_proj = False
self._debug = False
self.gui = True
self.tmpdir = path(get_openalea_tmp_dir())
self._config = MainConfig()
self.extension = None
self.applet = {}
self.manager = {}
self.package_manager = package_manager
self.control_manager = ControlManager()
self.project_manager = ProjectManager()
self.plugin_manager = PluginManager()
self.plugin_instance_manager = PluginInstanceManager()
self.manager['control'] = self.control_manager
self.manager['package'] = self.package_manager
self.manager['project'] = self.project_manager
self.manager['plugin'] = self.plugin_manager
self.manager['plugin_instance'] = self.plugin_instance_manager
self.world = World()
self.interpreter = interpreter()
# Hack if interpreter is an object from class TerminalInteractiveShell
if not hasattr(self.interpreter, "shell"):
self.interpreter.shell = self.interpreter
if hasattr(self.interpreter.shell, "events"):
self.interpreter.shell.events.register("post_execute",
self.add_to_history)
else:
print("You need ipython >= 2.0 to use history.")
# self.project_manager.set_shell(self.interpreter.shell)
self.interpreter.locals['session'] = self
self.old_syspath = sys.path
self.load_default()
self.__class__.instantiated = True
@property
def project(self):
"""
:return: current project if one is opened. Else return None.
"""
return self.project_manager.cproject
def load_config_file(self, filename, path=None):
self._config.load_config_file(filename=filename, path=path)
def clear(self):
self.world.clear()
self.control_manager.clear()
def load_default(self):
self.project_manager.load_default()
self.update_namespace()
def update_namespace(self):
"""
Definition: Update namespace
"""
self.interpreter.locals['world'] = self.world
self.interpreter.locals['get_control'] = self.control_manager.control
self.interpreter.locals[
'follow'] = self.control_manager.register_follower
self.interpreter.locals[
'unfollow'] = self.control_manager.unregister_follower
if self.project:
if self.project.path.exists():
os.chdir(self.project.path)
sys.path.insert(0, str(self.project.path / 'lib'))
else:
os.chdir(self.tmpdir)
sys.path.insert(0, str(self.tmpdir / 'lib'))
self.interpreter.locals.update(self.project.ns)
self.interpreter.locals['project'] = self.project
self.interpreter.locals['Model'] = get_model
self.interpreter.locals['data'] = self.project.path / 'data'
else:
# close
sys.path = self.old_syspath
def add_to_history(self, *args, **kwargs):
"""
Send the last sent of history to the components that display history
"""
from openalea.oalab.service.history import display_history
records = self.interpreter.shell.history_manager.get_range()
input_ = ''
# loop all elements in iterator to get last one.
# TODO: search method returning directly last input
for session, line, input_ in records:
pass
display_history(input_)
config = property(fget=lambda self: self._config.config)
@property
def debug_plugins(self):
return self.plugin_manager.debug
@property
def debug(self):
return self._debug
@debug.setter
def debug(self, enable):
"""
If True, add some objects useful for debug in shell namespace:
- applet: dict containing weak references to all applets
- manager: dict containing all managers
"""
self._debug = enable
env = self.interpreter.locals
if self._debug is True:
env['manager'] = self.manager
env['applet'] = self.applet
else:
for varname in ('applet', 'manager'):
if varname in env:
del env[varname]
from openalea.oalab.model.parse import InputObj, OutputObj
from openalea.core.model import Model
from openalea.core.service.run import namespace
from openalea.core.service.control import clear_controls
from openalea.core.project.manager import ProjectManager
import copy
pm = ProjectManager()
project = pm.create('unittest', '/tmp/notwritable')
pm.cproject = project
def register_model(model):
project.add('model', model)
def test_copy():
m = Model(name='m1')
m.set_step_code('c=a+b')
m.inputs_info = [InputObj('a'), InputObj('b')]
m.outputs_info = [OutputObj('c')]
m2 = copy.copy(m)
assert m is not m2
assert m.step_code == m2.step_code
assert [inp.name for inp in m2.inputs_info] == ['a', 'b']
assert [out.name for out in m2.outputs_info] == ['c']
def test_output():
def initialize(cls, *args, **kwds):
from openalea.core.project.manager import ProjectManager
pm = ProjectManager()
