def __init__(self, master=False, mod_path='modules', verbose=False):
DBusGMainLoop(set_as_default=True)
bus_name = dbus.service.BusName('org.gnuradio.grotarapi',
bus=dbus.SessionBus())
self.verbose = verbose
self.master = master
f = lambda: master == True and 'master' or 'slave'
self.gpg = gnupg.GPG(gnupghome=mod_path + '/' + f() + '/gnupghome')
if self.verbose:
for key in self.gpg.list_keys():
print '[INFO] CONTROLLER public key with fingerprint', key[
'fingerprint']
if master:
dbus.service.Object.__init__(
self, bus_name, '/org/gnuradio/grotarapi/controller/master')
self.gr = GrotarAPI.GrotarAPIMaster(self, self.verbose)
self.mm = ModuleManager.ModuleManager(mod_path=mod_path +
'/master',
verbose=verbose)
self.mm_slave = ModuleManager.ModuleManager(mod_path=mod_path +
'/slave',
verbose=verbose)
else:
dbus.service.Object.__init__(
self, bus_name, '/org/gnuradio/grotarapi/controller/slave')
self.gr = GrotarAPI.GrotarAPISlave(self, self.verbose)
self.mm = ModuleManager.ModuleManager(mod_path=mod_path + '/slave',
verbose=verbose)
self.cur_module = None
self.cur_module_name = ''
def __init__(self, *args, **kw):
super(BaseWindow, self).__init__(*args, **kw)
self.Maximize(True)
self.currentDirectory = os.getcwd()
self.project = Project()
self.pnl = wx.Panel(self,
size=self.Size,
style=wx.TAB_TRAVERSAL | wx.BORDER_SUNKEN)
self.sizer = wx.BoxSizer(wx.HORIZONTAL)
collap = wx.Panel(self.pnl,
size=(260, self.Size[1]),
style=wx.TAB_TRAVERSAL | wx.BORDER_SUNKEN)
self.hintPnl = HintPanel(collap)
self.logPnl = ConsolePanel(collap)
self.moduleManager = ModuleManager(self.pnl, self.project, self.logPnl)
self.aux = Project()
# create the menu bar that we don't need yet
self.makeMenuBar(self.logPnl)
csizer = wx.BoxSizer(wx.VERTICAL)
csizer.Add(self.hintPnl)
csizer.Add(self.logPnl)
collap.SetSizer(csizer)
# create the status bar
self.CreateStatusBar()
self.SetStatusText("")
self.sizer.Add(collap)
self.sizer.Add(self.moduleManager)
self.pnl.SetSizer(self.sizer)
self.Bind(wx.EVT_CLOSE, self.OnClose)
def __init__(self, master = False):
Controller.Controller(master = master, mod_path = '/tmp/grotarapitest', verbose = False)
self.sent = list()
self.cur_module = None
if master:
self.mm = ModuleManager.ModuleManager(mod_path = '/tmp/grotarapitest/master', verbose = True)
self.mm_slave = ModuleManager.ModuleManager(mod_path = '/tmp/grotarapitest/slave', verbose = True)
else:
self.mm = ModuleManager.ModuleManager(mod_path = '/tmp/grotarapitest/slave', verbose = True)
self.added_modules = list()
def onItemClicked(self, item, column):
if column == 1:
self.valueBeforeEdit = str(item.text(column))
if item.text(0) == "State":
ed = GameObjectStateEditor(item.text(column), self)
ed.exec_()
item.setText(column, ed.getValue())
self.node.getAttachedObject(0).getUserObject().state = ed.getValue()
elif item.text(0) == "Receives Shadows":
bedit = BoolEditor(item.text(column), self)
bedit.exec_()
item.setText(column, bedit.getValue())
self.node.getAttachedObject(0).getUserObject().receivesShadow = str(bedit.getValue())
elif item.text(0) == "Physics Proxy Type":
bedit = EntityPhysicsProxyEditor(item.text(column), self)
bedit.exec_()
item.setText(column, bedit.getValue())
self.node.getAttachedObject(0).getUserObject().physicsproxytype = bedit.getValue()
elif item.text(0) == "Visibility":
bedit = BoolEditor(item.text(column), self)
bedit.exec_()
item.setText(column, str(bedit.getValue()))
ModuleManager.extractLight(self.node).setVisible(bedit.getValue())
elif item.text(0) == "CastShadows":
bedit = BoolEditor(item.text(column), self)
bedit.exec_()
item.setText(column, str(bedit.getValue()))
ModuleManager.extractLight(self.node).setCastShadows(bedit.getValue())
elif item.text(0) == "Diffuse Color":
min = 1.0 / 255.0
col = ModuleManager.extractLight(self.node).getDiffuseColour()
newColor = QColorDialog.getColor(QColor(col.r * 255, col.g * 255, col.g * 255), self)
ModuleManager.extractLight(self.node).setDiffuseColour(og.ColourValue(min * newColor.red(), min * newColor.green(), min * newColor.blue()))
self.showProperties(self.so)
elif item.text(0) == "Specular Color":
min = 1.0 / 255.0
col = ModuleManager.extractLight(self.node).getSpecularColour()
newColor = QColorDialog.getColor(QColor(col.r * 255, col.g * 255, col.g * 255), self)
ModuleManager.extractLight(self.node).setSpecularColour(og.ColourValue(min * newColor.red(), min * newColor.green(), min * newColor.blue()))
self.showProperties(self.so)
elif item.text(0) == "Subtract":
bedit = BoolEditor(item.text(column), self)
bedit.exec_()
item.setText(column, str(bedit.getValue()))
self.so.entity.getUserObject().subtract = bedit.getValue()
else:
self.treeWidget.editItem(item, column)
def __init__(self):
"""
DatastoreManager constructor.
"""
# Let's get the instance of ModuleManager, since we will use it a lot in this class
self.moduleManager = ModuleManager.getInstance()
self.prefixes = self.moduleManager.getPrefixes()
# Declare running (see get operation), runningConfig (see get-config operation),
# candidate and startup configuration datastores. These are XML documents, not nodes.
# Self.configurations dictionnary contains all the configurations.
self.configurations = {}
self.configurations[C.STARTUP] = {}
self.configurations[C.CANDIDATE] = {}
self.configurations[C.RUNNING] = {}
self.configurations[C.STARTUP]["state"] = None
self.configurations[C.STARTUP]["config"] = None
self.configurations[C.CANDIDATE]["state"] = None
self.configurations[C.CANDIDATE]["config"] = None
self.configurations[C.RUNNING]["state"] = None
self.configurations[C.RUNNING]["config"] = None
self.initializeAll(C.RUNNING)
self.initializeAll(C.STARTUP)
def __init__(self):
"""
DatastoreManager constructor.
"""
# Let's get the instance of ModuleManager, since we will use it a lot in this class
self.moduleManager = ModuleManager.getInstance()
self.prefixes = self.moduleManager.getPrefixes()
# Declare running (see get operation), runningConfig (see get-config operation),
# candidate and startup configuration datastores. These are XML documents, not nodes.
# Self.configurations dictionnary contains all the configurations.
self.configurations = {}
self.configurations[C.STARTUP] = {}
self.configurations[C.CANDIDATE] = {}
self.configurations[C.RUNNING] = {}
self.configurations[C.STARTUP]["state"] = None
self.configurations[C.STARTUP]["config"] = None
self.configurations[C.CANDIDATE]["state"] = None
self.configurations[C.CANDIDATE]["config"] = None
self.configurations[C.RUNNING]["state"] = None
self.configurations[C.RUNNING]["config"] = None
self.initializeAll(C.RUNNING)
self.initializeAll(C.STARTUP)
# add by manu 04/09
# to init a candidate configuration
self.initializeAll(C.CANDIDATE)
def setupOgre(self, pluginCfgPath="./Plugins.cfg", ogreCfgPath="./ogre.cfg", logPath="./ogre.log"):
if platform.system() == "Windows":
pluginCfgPath="./Plugins-windows.cfg"
else:
pluginCfgPath="./Plugins-linux.cfg"
root = og.Root(pluginCfgPath, ogreCfgPath, logPath)
self.ogreRoot = root
if not self.ogreRoot.restoreConfig() and not self.ogreRoot.showConfigDialog():
sys.exit('Quit from Config Dialog')
root.initialise(False)
self.OgreMainWinSceneMgr = self.ogreRoot.createSceneManager(og.ST_GENERIC, "OgreMainWinSceneMgr")
self.OgreMainWinSceneMgr.ambientLight = og.ColourValue(4, 4, 4)
self.moduleName = ""
self.moduleManager = ModuleManager(self.ogreRoot, self.OgreMainWinSceneMgr)
self.ogreMainWindow = OgreMainWindow.OgreMainWindow(self.moduleManager, root, self.OgreMainWinSceneMgr, self)
self.gridlayout.addWidget(self.ogreMainWindow,0,0,1,1)
self.hboxlayout.addLayout(self.gridlayout)
self.setCentralWidget(self.centralwidget)
og.ResourceGroupManager.getSingleton().addResourceLocation("./media", "FileSystem", "General", False)
og.ResourceGroupManager.getSingleton().initialiseAllResourceGroups()
self.moduleManager.pivot = Pivot(self.OgreMainWinSceneMgr)
self.moduleManager.pivot.hide()
oglog = og.LogManager.getSingleton().getDefaultLog()
oglog.addListener(self.consoleWindow.lockenLog)
def setUp(self):
try:
os.mkdir('/tmp/module_test')
except OSError:
shutil.rmtree('/tmp/module_test')
os.mkdir('/tmp/module_test')
self.mm = ModuleManager.ModuleManager(mod_path='/tmp/module_test',
verbose=False)
def recordAttendance(name):
print("Module Record System(Attendance) - Choose a Module")
print("---------------------------------------------------")
moduleManager = ModuleManager(MODULE_FILE)
modules = moduleManager.getModulesByLecturer(name)
for i in range(len(modules)):
print(i + 1, ". ", modules[i].code)
choice = int(input(">"))
if 1 <= choice <= len(modules):
module = modules[choice - 1]
#Allows a teacher to add attendance for a module
print("There are ", str(len(module.students)), " students enrolled.")
for i in range(len(module.students)):
student = module.students[i]
user_input = ""
while user_input == "":
print("Student #", i + 1, " ", student.name)
print("1. Present")
print("2. Absent")
print("3. Excused")
user_input = int(input(">"))
if user_input == 1:
student.present += 1
elif user_input == 2:
student.absent += 1
elif user_input == 3:
student.excused += 1
else:
user_input = ""
print("Error! Input out of range!\n")
if user_input != "":
module.update()
else:
print("Error! Input out of range\n")
def __init__(self, master: tk.Tk):
self._master = master
self._master.geometry(const.APP_GEOMETRY)
self.mview = Bomb.BombView(self._master)
self.model = Bomb.BombModel(const.DEFAULT_TIME_LIMIT, self.on_window_close)
self.model.attach_modules(ModuleManager.get_module_list(self.model, self.mview))
self.mview.attach_module_list(self.model.modules)
self.eview = Bomb.EdgeworkView(self._master, self.model)
self.model.attach_edgework_view(self.eview)
self.mview.pack(side=tk.LEFT, expand=True, fill=tk.BOTH, padx=20)
self.eview.pack(side=tk.LEFT, fill=tk.BOTH, padx=10)
self.model.start_game()
def __init__(self):
self.lock = threading.Lock()
self.args = None
self.database = None
self.config = None
self.bot_directory = os.path.dirname(os.path.realpath(__file__))
self.servers = {}
self.running = True
self.poll = select.epoll()
self.modules = ModuleManager.ModuleManager(self)
self.events = EventManager.EventHook(self)
self.timers = []
self.events.on("timer").on("reconnect").hook(self.reconnect)
self.events.on("boot").on("done").hook(self.setup_timers)
def generateStatistics(name):
print("Module Record System(Statistics) - Choose a Module")
print("---------------------------------------------------")
moduleManager = ModuleManager(MODULE_FILE)
#Gets all modules
modules = moduleManager.getModulesByLecturer(name)
for i in range(len(modules)):
print(i + 1, ". ", modules[i].code)
choice = int(input(">"))
if 1 <= choice <= len(modules):
module = modules[choice - 1]
#generate statistics
module_statistics = module.generate_statistics()
print(module_statistics)
#save statistics
module.save_statistics(module_statistics)
else:
print("Error! Input out of range!")
def parseSpotLightProperties(self, node):
light = ModuleManager.extractLight(self.node)
item = QTreeWidgetItem(self.treeWidget)
item.setText(0, "Spotlightrange")
inner = QTreeWidgetItem(item)
inner.setText(0, "inner")
inner.setText(1, str(light.getSpotlightInnerAngle().valueDegrees()))
inner.setFlags(inner.flags() | Qt.ItemIsEditable)
outer = QTreeWidgetItem(item)
outer.setText(0, "outer")
outer.setText(1, str(light.getSpotlightOuterAngle().valueDegrees()))
outer.setFlags(outer.flags() | Qt.ItemIsEditable)
falloff = QTreeWidgetItem(item)
falloff.setText(0, "falloff")
falloff.setText(1, str(light.getSpotlightFalloff()))
falloff.setFlags(falloff.flags() | Qt.ItemIsEditable)
def __init__(self):
self.start_time = time.time()
self.lock = threading.Lock()
self.args = None
self.database = None
self.config = None
self.bot_directory = os.path.dirname(os.path.realpath(__file__))
self.servers = {}
self.running = True
self.poll = select.epoll()
self._events = EventManager.EventHook(self)
self._exports = Exports.Exports()
self.modules = ModuleManager.ModuleManager(self, self._events,
self._exports)
self.log = Logging.Log(self)
self.line_handler = IRCLineHandler.LineHandler(self, self._events)
self.timers = []
self._events.on("timer.reconnect").hook(self.reconnect)
self._events.on("boot.done").hook(self.setup_timers)
def parseLightAttenuation(self, node):
item = QTreeWidgetItem(self.treeWidget)
item.setText(0, "Attenuation")
light = ModuleManager.extractLight(self.node)
range = QTreeWidgetItem(item)
range.setText(0, "range")
range.setText(1, str(light.getAttenuationRange()))
range.setFlags(range.flags() | Qt.ItemIsEditable)
constant = QTreeWidgetItem(item)
constant.setText(0, "constant")
constant.setText(1, str(light.getAttenuationConstant()))
constant.setFlags(constant.flags() | Qt.ItemIsEditable)
linear = QTreeWidgetItem(item)
linear.setText(0, "linear")
linear.setText(1, str(light.getAttenuationLinear()))
linear.setFlags(linear.flags() | Qt.ItemIsEditable)
quadratic = QTreeWidgetItem(item)
quadratic.setText(0, "quadratic")
quadratic.setText(1, str(light.getAttenuationQuadric()))
quadratic.setFlags(quadratic.flags() | Qt.ItemIsEditable)
class Lockenwickler(QtGui.QMainWindow):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
# pixmap = QPixmap("media/icons/lockenwickler_provisorium.png")
# splash = QSplashScreen(pixmap, Qt.WindowStaysOnTopHint)
# splash.setMask(pixmap.mask())
# splash.showMessage("Starting...")
# splash.show()
self.setupUi()
self.consoleWindow = ConsoleWindow(False, self)
self.setupOgre()
self.prefDialog = PreferencesDialog(self)
self.objectPropertyWin = ObjectPropertyWin(self)
self.moduleExplorerWin = ModuleExplorer(self)
self.modelSelectionDialog = ModelSelectionDialog(self.ogreRoot, self)
self.moduleManager.modelSelectionDialog = self.modelSelectionDialog
self.gameObjectClassView = GameObjectClassView(self.moduleManager.gocManager)
self.createDockWindows()
self.mainTimer = QtCore.QTimer(self)
self.mainTimer.connect(self.mainTimer, QtCore.SIGNAL("timeout()"), self.update)
self.mainTimer.start(5)
settings = QtCore.QSettings()
self.restoreGeometry(settings.value("MainWindow/Geometry").toByteArray())
self.restoreState(settings.value("MainWindow/DockWindows").toByteArray())
if not self.prefDialog.setCfgPath(settings.value("Preferences/moduleCfgPath").toString()):
self.prefDialog.show()
self.moduleManager.moduleCfgPath = self.prefDialog.moduleCfgPath
self.moduleManager.moduleExplorer = self.moduleExplorerWin
self.setWindowIcon(QIcon("media/icons/lockenwickler_provisorium_small.png"))
self.setWindowTitle("Rastullahs Lockenwickler")
# splash.finish(self)
def createAction(self, text, slot=None, shortcut=None, icon=None, tip=None, checkable=False, signal="triggered()"):
action = QtGui.QAction(text, self)
if icon is not None:
action.setIcon(QtGui.QIcon("media/icons/%s" % icon))
if shortcut is not None:
action.setShortcut(shortcut)
if tip is not None:
action.setToolTip(tip)
action.setStatusTip(tip)
if slot is not None:
self.connect(action, QtCore.SIGNAL(signal), slot)
action.setCheckable(checkable)
return action
def addActions(self, target, actions):
for act in actions:
if act is None:
target.addSeparator()
else:
target.addAction(act)
def setupUi(self):
self.setObjectName("MainWindow")
self.centralwidget = QtGui.QWidget(self)
self.centralwidget.setObjectName("centralwidget")
self.hboxlayout = QtGui.QHBoxLayout(self.centralwidget)
self.hboxlayout.setObjectName("hboxlayout")
self.gridlayout = QtGui.QGridLayout()
self.gridlayout.setObjectName("gridlayout")
self.menubar = QtGui.QMenuBar(self)
self.menubar.setObjectName("menubar")
self.menuFile = QtGui.QMenu(self.menubar)
self.menuFile.setObjectName("menuFile")
self.menuEdit = QtGui.QMenu(self.menubar)
self.menuEdit.setObjectName("menuEdit")
self.menuView = QtGui.QMenu(self.menubar)
self.menuView.setObjectName("menuView")
self.setMenuBar(self.menubar)
self.statusbar = QtGui.QStatusBar(self)
self.statusbar.setObjectName("statusbar")
self.setStatusBar(self.statusbar)
#####################################
self.actionNeu =self.createAction("&New Module", self.actionNewSlot, QKeySequence.New, "filenew.png", "New Module")
self.actionNeu.setObjectName("actionNeu")
self.actionOpen = self.createAction("&Open Module", self.actionOpenSlot, QKeySequence.Open, "filenew.png", "Open Module")
self.actionOpen.setObjectName("actionOpen")
self.actionClose = self.createAction("Quit", self.actionQuitSlot, "Alt + Q", "exit.png", "Quit")
self.actionClose.setObjectName("actionQuit")
#####################################
#####################################
self.actionDelete = self.createAction("Delete", self.actionDeleteSlot, QKeySequence.Delete, "editdelete.png", "Delete")
self.actionDelete.setObjectName("actionDelete")
self.actionCopy = self.createAction("Copy", self.actionCopySlot, QKeySequence.Copy, "editcopy.png", "Copy")
self.actionCopy.setObjectName("actionCopy")
self.actionCut = self.createAction("Cut", self.actionCutSlot, QKeySequence.Cut, "editcut.png", "Cut")
self.actionCut.setObjectName("actionCut")
self.actionPaste = self.createAction("Paste", self.actionPasteSlot, QKeySequence.Paste, "editpaste.png", "Paste")
self.actionPaste.setObjectName("actionPaste")
self.actionSelect = self.createAction("&Select", self.actionSelectSlot, "Space", "cursor.png", "Move selected object")
self.actionSelect.setObjectName("actionSelect")
self.actionMove = self.createAction("&Move", self.actionMoveSlot, "g", "move.png", "Move selected object")
self.actionMove.setObjectName("actionMove")
self.actionRotate = self.createAction("&Rotate", self.actionRotateSlot, "r", "rotate.png", "Rotate selected object")
self.actionRotate.setObjectName("actionRotate")
self.actionScale = self.createAction("&Scale", self.actionScaleSlot, "x", "resizecol.png", "Scale selected object")
self.actionRotate.setObjectName("actionRotate")
#####################################
#####################################
self.actionSceneExplorer = self.createAction("&Scene Exlporer", self.toggleModuleExplorer, "Alt + E", "view_tree.png", "Module Explorer", False)
self.actionSceneExplorer.setObjectName("actionSceneExplorer")
self.actionPreferences = self.createAction("&Preferences", self.togglePreferencesWindow, "Alt + P", "configure.png", "Lockenwickler Preferences", False)
self.actionPreferences.setObjectName("actionPreferences")
self.actionProperty_Window = self.createAction("Pr&operty Window", self.togglePropertyWindow, "Alt + P", "unsortedlist1.png", "Property Window")
self.actionProperty_Window.setObjectName("actionProperty_Window")
self.actionObject_Selection = self.createAction("&Model Preview Window", self.toggleModelPreviewWindow, "Alt + O", "tux.png", "Model Preview")
self.actionObject_Selection.setObjectName("actionObject_Selection")
self.actionGameObjectClass_Selection = self.createAction("&Game Object Class Preview Window", self.toggleGameObjectViewWindow, "Alt + G", "multirow.png", "GameObjectClass Preview")
self.actionGameObjectClass_Selection.setObjectName("actionObject_Selection")
self.actionConsole_Window = self.createAction("&Console Window", self.toggleConsoleWindow, "Alt + C", "console.png", "Console Window")
self.actionConsole_Window.setObjectName("actionConsole_Window")
#####################################
#####################################
self.menuFile.addAction(self.actionNeu)
self.menuFile.addAction(self.actionOpen)
self.menuFile.addAction(self.actionClose)
self.menuEdit.addAction(self.actionSelect)
self.menuEdit.addAction(self.actionMove)
self.menuEdit.addAction(self.actionRotate)
self.menuEdit.addAction(self.actionScale)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionDelete)
self.menuEdit.addAction(self.actionCopy)
self.menuEdit.addAction(self.actionCut)
self.menuEdit.addAction(self.actionPaste)
self.menuView.addAction(self.actionSceneExplorer)
self.menuView.addAction(self.actionPreferences)
self.menuView.addAction(self.actionProperty_Window)
self.menuView.addAction(self.actionObject_Selection)
self.menuView.addAction(self.actionGameObjectClass_Selection)
self.menuView.addAction(self.actionConsole_Window)
self.menubar.addAction(self.menuFile.menuAction())
self.menubar.addAction(self.menuEdit.menuAction())
self.menubar.addAction(self.menuView.menuAction())
self.retranslateUi()
QtCore.QMetaObject.connectSlotsByName(self)
def retranslateUi(self):
self.setWindowTitle(QtGui.QApplication.translate("MainWindow", "MainWindow", None, QtGui.QApplication.UnicodeUTF8))
self.menuFile.setTitle(QtGui.QApplication.translate("MainWindow", "File", None, QtGui.QApplication.UnicodeUTF8))
self.menuEdit.setTitle(QtGui.QApplication.translate("MainWindow", "Edit", None, QtGui.QApplication.UnicodeUTF8))
self.menuView.setTitle(QtGui.QApplication.translate("MainWindow", "View", None, QtGui.QApplication.UnicodeUTF8))
self.actionNeu.setText(QtGui.QApplication.translate("MainWindow", "New Module", None, QtGui.QApplication.UnicodeUTF8))
self.actionMove.setText(QtGui.QApplication.translate("MainWindow", "Move", None, QtGui.QApplication.UnicodeUTF8))
self.actionRotate.setText(QtGui.QApplication.translate("MainWindow", "Rotate", None, QtGui.QApplication.UnicodeUTF8))
self.actionSceneExplorer.setText(QtGui.QApplication.translate("MainWindow", "Module Explorer", None, QtGui.QApplication.UnicodeUTF8))
self.actionPreferences.setText(QtGui.QApplication.translate("MainWindow", "Preferences", None, QtGui.QApplication.UnicodeUTF8))
self.actionProperty_Window.setText(QtGui.QApplication.translate("MainWindow", "Property Window", None, QtGui.QApplication.UnicodeUTF8))
self.actionObject_Selection.setText(QtGui.QApplication.translate("MainWindow", "Object Selection", None, QtGui.QApplication.UnicodeUTF8))
self.actionClose.setText(QtGui.QApplication.translate("MainWindow", "Quit", None, QtGui.QApplication.UnicodeUTF8))
self.actionConsole_Window.setText(QtGui.QApplication.translate("MainWindow", "Console Window", None, QtGui.QApplication.UnicodeUTF8))
def setupOgre(self, pluginCfgPath="./Plugins.cfg", ogreCfgPath="./ogre.cfg", logPath="./ogre.log"):
if platform.system() == "Windows":
pluginCfgPath="./Plugins-windows.cfg"
else:
pluginCfgPath="./Plugins-linux.cfg"
root = og.Root(pluginCfgPath, ogreCfgPath, logPath)
self.ogreRoot = root
if not self.ogreRoot.restoreConfig() and not self.ogreRoot.showConfigDialog():
sys.exit('Quit from Config Dialog')
root.initialise(False)
self.OgreMainWinSceneMgr = self.ogreRoot.createSceneManager(og.ST_GENERIC, "OgreMainWinSceneMgr")
self.OgreMainWinSceneMgr.ambientLight = og.ColourValue(4, 4, 4)
self.moduleName = ""
self.moduleManager = ModuleManager(self.ogreRoot, self.OgreMainWinSceneMgr)
self.ogreMainWindow = OgreMainWindow.OgreMainWindow(self.moduleManager, root, self.OgreMainWinSceneMgr, self)
self.gridlayout.addWidget(self.ogreMainWindow,0,0,1,1)
self.hboxlayout.addLayout(self.gridlayout)
self.setCentralWidget(self.centralwidget)
og.ResourceGroupManager.getSingleton().addResourceLocation("./media", "FileSystem", "General", False)
og.ResourceGroupManager.getSingleton().initialiseAllResourceGroups()
self.moduleManager.pivot = Pivot(self.OgreMainWinSceneMgr)
self.moduleManager.pivot.hide()
oglog = og.LogManager.getSingleton().getDefaultLog()
oglog.addListener(self.consoleWindow.lockenLog)
def update(self):
self.ogreRoot.renderOneFrame()
def actionOpenSlot(self):
self.moduleManager.openLoadModuleDialog()
def actionNewSlot(self):
newModuleWiz = NewModuleWizard(self.moduleManager, self)
newModuleWiz.exec_()
return
def actionQuitSlot(self):
self.close()
def actionDeleteSlot(self):
self.moduleManager.deleteObjects()
def actionCopySlot(self):
self.moduleManager.copyObjects()
def actionCutSlot(self):
self.moduleManager.cutObjects()
def actionPasteSlot(self):
self.moduleManager.pasteObjects(self.ogreMainWindow.getCameraToViewportRay())
def actionSelectSlot(self):
self.moduleManager.pivot.hide()
def actionMoveSlot(self):
self.moduleManager.pivot.setMoveMode()
def actionRotateSlot(self):
self.moduleManager.pivot.setRotateMode()
def actionScaleSlot(self):
self.moduleManager.pivot.setScaleMode()
def togglePreferencesWindow(self):
if self.prefDialog.isHidden():
self.prefDialog.show()
else:
self.prefDialog.hide()
def toggleModelPreviewWindow(self):
if self.modelSelectionDock.isHidden():
self.modelSelectionDock.show()
else:
self.modelSelectionDock.hide()
def toggleGameObjectViewWindow(self):
if self.gameObjectClassViewDock.isHidden():
self.gameObjectClassViewDock.show()
else:
self.gameObjectClassViewDock.hide()
def toggleModuleExplorer(self):
if self.moduleExplorerDock.isHidden():
self.moduleExplorerDock.show()
else:
self.moduleExplorerDock.hide()
def togglePropertyWindow(self):
if self.propertyDock.isHidden():
self.propertyDock.show()
else:
self.propertyDock.hide()
def toggleConsoleWindow(self):
if self.consoleDock.isHidden():
self.consoleDock.show()
else:
self.consoleDock.hide()
def createDockWindows(self):
self.propertyDock = QtGui.QDockWidget(self.tr("Properties"), self)
self.propertyDock.setObjectName("PropertyDockWindow")
self.propertyDock.setAllowedAreas(QtCore.Qt.LeftDockWidgetArea | QtCore.Qt.RightDockWidgetArea)
self.propertyDock.setWidget(self.objectPropertyWin)
self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self.propertyDock)
self.modelSelectionDock = QtGui.QDockWidget(self.tr("Models"), self)
self.modelSelectionDock.setObjectName("ModelSelectionDockWindow")
self.modelSelectionDock.setAllowedAreas(QtCore.Qt.LeftDockWidgetArea | QtCore.Qt.RightDockWidgetArea)
self.modelSelectionDock.setWidget(self.modelSelectionDialog)
self.addDockWidget(QtCore.Qt.RightDockWidgetArea, self.modelSelectionDock)
self.gameObjectClassViewDock = QtGui.QDockWidget(self.tr("GameObjectClasses"), self)
self.gameObjectClassViewDock.setObjectName("GameObjectClassView")
self.gameObjectClassViewDock.setAllowedAreas(QtCore.Qt.LeftDockWidgetArea | QtCore.Qt.RightDockWidgetArea)
self.gameObjectClassViewDock.setWidget(self.gameObjectClassView)
self.addDockWidget(QtCore.Qt.RightDockWidgetArea, self.gameObjectClassViewDock)
self.moduleExplorerDock = QtGui.QDockWidget(self.tr("Module Explorer"), self)
self.moduleExplorerDock.setObjectName("SceneExplorerDockWindow")
self.moduleExplorerDock.setAllowedAreas(QtCore.Qt.LeftDockWidgetArea | QtCore.Qt.RightDockWidgetArea)
self.moduleExplorerDock.setWidget(self.moduleExplorerWin)
self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self.moduleExplorerDock)
self.consoleDock = QtGui.QDockWidget(self.tr("Console"), self)
self.consoleDock.setObjectName("ConsoleDockWindow")
self.consoleDock.setAllowedAreas(QtCore.Qt.BottomDockWidgetArea | QtCore.Qt.TopDockWidgetArea)
self.consoleDock.setWidget(self.consoleWindow)
self.addDockWidget(QtCore.Qt.BottomDockWidgetArea, self.consoleDock)
self.fileToolBar = self.addToolBar("File Toolbar")
self.fileToolBar.setObjectName("FileToolBar")
self.fileToolBar.setAllowedAreas(QtCore.Qt.TopToolBarArea | QtCore.Qt.BottomToolBarArea)
self.fileToolBar.addAction(self.actionNeu)
self.fileToolBar.addAction(self.actionClose)
self.addToolBar(QtCore.Qt.TopToolBarArea, self.fileToolBar)
self.moveToolBar = self.addToolBar("Transformation Bar")
self.moveToolBar.setObjectName("TransformationBar")
self.moveToolBar.setAllowedAreas(QtCore.Qt.TopToolBarArea | QtCore.Qt.BottomToolBarArea)
self.moveToolBar.addAction(self.actionSelect)
self.moveToolBar.addAction(self.actionMove)
self.moveToolBar.addAction(self.actionRotate)
self.moveToolBar.addAction(self.actionScale)
self.addToolBar(QtCore.Qt.TopToolBarArea, self.moveToolBar)
def keyPressEvent(self, event):
if not event.isAutoRepeat():
self.ogreMainWindow.keyPressEvent(event)
def keyReleaseEvent(self, event):
if not event.isAutoRepeat():
self.ogreMainWindow.keyReleaseEvent(event)
pass
def connectActionButtons(self):
pass
def saveOnClose(self):
reply = QtGui.QMessageBox.question(self, "Rastullahs Lockenwickler - Unsaved Chages", "Save unsaved changes?", QtGui.QMessageBox.Yes|QtGui.QMessageBox.No|QtGui.QMessageBox.Cancel)
if reply == QtGui.QMessageBox.Cancel:
return False
if reply == QtGui.QMessageBox.Yes:
print""
#TODO: implement save here
return True
def closeEvent(self, event):
if self.saveOnClose():
settings = QtCore.QSettings()
settings.setValue("Preferences/moduleCfgPath", QtCore.QVariant(self.prefDialog.lineEdit.text()))
settings.setValue("MainWindow/Geometry", QtCore.QVariant(self.saveGeometry()))
settings.setValue("MainWIndow/DockWindows", QtCore.QVariant(self.saveState()))
else:
event.ignore()
class TestModuleManager(unittest.TestCase):
def setUp(self):
self.mm = ModuleManager(OpenRTM_aist.Properties(defaults_str=configsample_spec))
def tearDown(self):
del self.mm
OpenRTM_aist.Manager.instance().shutdownManager()
def test_load_unload(self):
try:
path = os.getcwd()
self.mm.load(path+"/hoge.py","echo")
self.mm.unload(path+"/hoge.py")
self.mm.load("hoge","echo")
self.mm.unload("hoge")
self.mm.load("hoge.py","echo")
self.mm.unload("hoge.py")
self.mm.load("./hoge.py","echo")
self.mm.unload("./hoge.py")
# Failure Pattern
#self.mm.load("sample")
except:
print "exception."
return
def test_unloadAll(self):
self.mm.unloadAll()
return
def test_symbol(self):
path = os.getcwd()
self.mm.load(path+"/hoge.py","echo")
self.mm.symbol(path+"/hoge.py","echo")()
self.mm.unload(path+"/hoge.py")
self.mm.load("hoge","echo")
self.mm.symbol("hoge","echo")()
self.mm.unload("hoge")
self.mm.load("hoge.py","echo")
self.mm.symbol("hoge.py","echo")()
self.mm.unload("hoge.py")
def test_setLoadpath(self):
self.mm.setLoadpath(["/usr/lib/python/site-packages","."])
return
def test_getLoadPath(self):
self.mm.setLoadpath(["/usr/lib/python/site-packages","."])
self.assertEqual(self.mm.getLoadPath()[0],"/usr/lib/python/site-packages")
return
def test_addLoadpath(self):
self.mm.setLoadpath(["/usr/lib/python/site-packages","."])
self.mm.addLoadpath(["/usr/local/lib/python/site-packages"])
self.assertEqual(self.mm.getLoadPath()[0],"/usr/lib/python/site-packages")
self.assertEqual(self.mm.getLoadPath()[-1],"/usr/local/lib/python/site-packages")
return
def test_getLoadedModules(self):
self.mm.load("hoge","echo")
self.assertNotEqual(self.mm.getLoadedModules()[0],None)
return
def test_allowAbsolutePath(self):
self.mm.allowAbsolutePath()
return
def test_disallowAbsolutePath(self):
self.mm.disallowAbsolutePath()
return
def test_allowModuleDownload(self):
self.mm.allowModuleDownload()
return
def test_disallowModuleDownload(self):
self.mm.disallowModuleDownload()
return
def test_findFile(self):
self.assertEqual(self.mm.findFile("hoge",["."]),"hoge")
self.assertEqual(self.mm.findFile("hoge.py",["."]),"hoge.py")
self.assertEqual(self.mm.findFile("hogehoge",["."]),"")
return
def test_fileExist(self):
self.assertEqual(self.mm.fileExist("hoge.py"),True)
self.assertEqual(self.mm.fileExist("./hoge.py"),True)
self.assertEqual(self.mm.fileExist("hoge"),True)
self.assertEqual(self.mm.fileExist("./hoge"),True)
self.assertEqual(self.mm.fileExist("hogehoge"),False)
return
def test_getInitFuncName(self):
self.mm.getInitFuncName("hoge.py")
return
def test_getRtcProfile(self):
self.assertEqual(self.mm._ModuleManager__getRtcProfile("./ConfigSample.py"),None)
self.assertEqual(self.mm._ModuleManager__getRtcProfile("ConfigSample.py"),None)
self.assertEqual(self.mm._ModuleManager__getRtcProfile("ConfigSample"),None)
return
def test_getLoadableModules(self):
self.mm.setLoadpath([".","./","../"])
self.assertNotEqual(self.mm.getLoadableModules(),[])
return
def setUp(self): self.mm = ModuleManager(OpenRTM_aist.Properties(defaults_str=configsample_spec))
class BaseWindow(wx.Frame):
def __init__(self, *args, **kw):
super(BaseWindow, self).__init__(*args, **kw)
self.Maximize(True)
self.currentDirectory = os.getcwd()
self.project = Project()
self.pnl = wx.Panel(self,
size=self.Size,
style=wx.TAB_TRAVERSAL | wx.BORDER_SUNKEN)
self.sizer = wx.BoxSizer(wx.HORIZONTAL)
collap = wx.Panel(self.pnl,
size=(260, self.Size[1]),
style=wx.TAB_TRAVERSAL | wx.BORDER_SUNKEN)
self.hintPnl = HintPanel(collap)
self.logPnl = ConsolePanel(collap)
self.moduleManager = ModuleManager(self.pnl, self.project, self.logPnl)
self.aux = Project()
# create the menu bar that we don't need yet
self.makeMenuBar(self.logPnl)
csizer = wx.BoxSizer(wx.VERTICAL)
csizer.Add(self.hintPnl)
csizer.Add(self.logPnl)
collap.SetSizer(csizer)
# create the status bar
self.CreateStatusBar()
self.SetStatusText("")
self.sizer.Add(collap)
self.sizer.Add(self.moduleManager)
self.pnl.SetSizer(self.sizer)
self.Bind(wx.EVT_CLOSE, self.OnClose)
# self.logThread = threading.Thread(target=log_task, args=(self.logPnl,))
# self.logThread.start()
def HidePossible(self, event):
self.moduleManager.HidePossible()
event.Skip()
def OnClose(self, event):
if self.__eq__() == False:
opc = 0
with WindowSaveOnExit(self, opc) as dlg:
dlg.ShowModal()
if dlg.opc == 1:
self.OnSave(0)
self.Destroy()
elif dlg.opc == 2:
self.Destroy()
else:
self.Destroy()
def setAux(self, p):
self.aux = deepcopy(p)
def __eq__(self):
firstCheck = True
key = self.project.__dict__.keys()
for i in key:
if i != 'EEGS':
if self.project.__dict__[i] != self.aux.__dict__[i]:
firstCheck = False
secondCheck = True
len1 = len(self.project.EEGS)
len2 = len(self.aux.EEGS)
if len1 != len2:
secondCheck = False
else:
u = 0
while u < len1:
if self.project.EEGS[
u].system10_20.__dict__ != self.project.EEGS[
u].system10_20.__dict__:
secondCheck = False
ch1 = len(self.project.EEGS[u].channels)
ch2 = len(self.aux.EEGS[u].channels)
if ch1 != ch2:
secondCheck = False
else:
p = 0
while p < ch1:
if self.project.EEGS[u].channels[
p].__dict__ != self.project.EEGS[u].channels[
p].__dict__:
secondCheck = False
p += 1
wn1 = len(self.project.EEGS[u].windows)
wn2 = len(self.aux.EEGS[u].windows)
if wn1 != wn2:
secondCheck = False
else:
p = 0
while p < wn1:
if self.project.EEGS[u].windows[
p].__dict__ != self.project.EEGS[u].windows[
p].__dict__:
secondCheck = False
p += 1
keys = self.project.EEGS[u].__dict__.keys()
# print(self.project.EEGS[u].__dict__)
# print(self.aux.EEGS[u].__dict__)
for k in keys:
if k != 'system10_20' and k != 'channels' and k != 'windows' and k != 'channelMatrix':
if self.project.EEGS[u].__dict__[k] != self.aux.EEGS[
u].__dict__[k]:
secondCheck = False
u += 1
if secondCheck and firstCheck:
return True
else:
return False
def makeMenuBar(self, log):
"""
A menu bar is composed of menus, which are composed of menu items.
This method builds a se of menus and binds handlers to be called
when the menu item is selected.
"""
self.log = log
# Make a file menu with Hello and Exit items
fileMenu = wx.Menu()
# The "\t..." syntax defines an accelerator key that also triggers
# the same event
loadSessionItem = fileMenu.Append(-1, "&Cargar Proyecto...\tCtrl-A",
"Carga un Proyecto anterior.")
saveSessionItem = fileMenu.Append(-1, "&Guardar Proyecto...\tCtrl-S",
"Guarda el Proyecto actual.")
fileMenu.AppendSeparator()
# When using a stock ID we don't need to specify the menu item's
# label
exitItem = fileMenu.Append(-1, "&Salir", "Cerrar el programa.")
# Now a help menu for the about item
helpMenu = wx.Menu()
aboutItem = helpMenu.Append(-1, "&Ayuda")
# Make the menu bar and add the two menus to it. The '&' defines
# that the next letter is the "mnemonic" for the menu item. On the
# platforms that support it those letters are underlined and can be
# triggered from the keyboard.
menuBar = wx.MenuBar()
menuBar.Append(fileMenu, "&Proyecto")
menuBar.Append(helpMenu, "&Ayuda")
# Give the menu bar to the frame
self.SetMenuBar(menuBar)
self.lastText = ""
# Finally, associate a handler function with the EVT_MENU event for
# each of the menu items. That means that when that menu item is
# activated then the associated handler function will be called.
self.Bind(wx.EVT_MENU, self.OnSave, saveSessionItem)
self.Bind(wx.EVT_MENU, self.OnLoad, loadSessionItem)
self.Bind(wx.EVT_MENU, self.OnExit, exitItem)
self.Bind(wx.EVT_MENU, self.OnAbout, aboutItem)
def setStatus(self, st, mouse):
self.SetStatusText(st)
if mouse == 0:
myCursor = wx.Cursor(wx.CURSOR_ARROW)
self.SetCursor(myCursor)
elif mouse == 1:
myCursor = wx.Cursor(wx.CURSOR_WAIT)
self.SetCursor(myCursor)
def setlog(self, text):
if text == "":
text = self.lastText + " (Finalizado)."
currentDT = datetime.datetime.now()
self.log.append_txt(currentDT.strftime("%H:%M:%S") + " " + text + "\n")
self.lastText = text
def OnExit(self, event):
"""Close the frame, terminating the application."""
self.Close(True)
def OnAbout(self, event):
"""Display an About Dialog"""
self.SetStatusText("")
wx.MessageBox(
"Abre el editor de archivos con doble clic en 'Archivo'.\n"
"Para añadir Procesos a los archivos de clic sobre 'Archivo'.\n"
"Dentro del Editor de archivos puedes abrir el Editor de Ventanas.",
"Como usar el Programa.", wx.OK | wx.ICON_INFORMATION)
def OnSave(self, event):
"""Save project session"""
dlg = wx.FileDialog(self, "Guardar como", self.currentDirectory, "", wildcard, \
wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT)
result = dlg.ShowModal()
path = dlg.GetPath()
dlg.Destroy()
if result == wx.ID_OK:
self.setStatus("Guardando...", 1)
self.setlog("Guardando...")
self.project.setTree(self.moduleManager.GetTree())
# Saving the new name for the project
name = str(path).split("\\")
name = name[len(name) - 1].split(".")[0]
self.project.name = name
outfile = gzip.open(path, 'wb')
_pickle.dump(len(self.project.EEGS), outfile, protocol=4)
for i in range(len(self.project.EEGS)):
_pickle.dump(self.project.EEGS[i], outfile, protocol=4)
self.project.EEGS = []
t = self.moduleManager.GetTree()
self.treeSave(t, outfile)
self.project.moduleTree = []
_pickle.dump(self.project, outfile, protocol=4)
outfile.close()
self.setStatus("", 0)
self.setlog("")
self.setAux(self.project)
return True
elif result == wx.ID_CANCEL:
self.setAux(self.project)
return False
def treeSave(self, module, file):
# Root no tiene datos solo un hijo
# salvar hijo
self.saveChildren(module.children, file)
module.children = []
# salvar root
_pickle.dump(module, file, protocol=4)
def treeLoad(self, file):
children = self.loadChildren(file)
module = _pickle.load(file)
module.children = children
return module
def loadChildren(self, file):
children = []
nChildren = _pickle.load(file)
if nChildren > 0:
for i in range(nChildren):
chil = self.loadChildren(file)
eegs = self.loadEEGs(file)
childrenR = _pickle.load(file)
childrenR.eegs = eegs
childrenR.children = chil
children.append(childrenR)
return children
def loadEEGs(self, file):
num = _pickle.load(file)
eegs = []
for i in range(num):
eegs.append(_pickle.load(file))
return eegs
def saveChildren(self, child_list, file):
# Listado de hijos
_pickle.dump(len(child_list), file, protocol=4)
for ch in child_list:
# Salvar Children
self.saveChildren(ch.children, file)
ch.children = []
# Salvar EEGs
self.saveEEGS(file, ch.eegs)
ch.eegs = []
ch.parent = []
_pickle.dump(ch, file, protocol=4)
def saveEEGS(self, file, eegs):
_pickle.dump(len(eegs), file, protocol=4)
for i in range(len(eegs)):
_pickle.dump(eegs[i], file, protocol=4)
def OnLoad(self, event):
"""Load project session"""
dlg = wx.FileDialog(self,
message="Cargar",
defaultDir=self.currentDirectory,
defaultFile="",
wildcard=wildcard,
style=wx.FD_OPEN | wx.FD_MULTIPLE)
if dlg.ShowModal() == wx.ID_OK:
# close all open windows
self.moduleManager.closeWindows()
if len(self.project.EEGS) > 0:
opc = 0
with WindowSaveOnExit(self, opc) as dl:
dl.ShowModal()
if dl.opc == 1:
self.OnSave(0)
elif dl.opc == 2:
path = dlg.GetPath()
self.loadProcess(path)
elif dl.opc == 3:
return
else:
self.setStatus("Cargando...", 1)
self.setlog("Cargando...")
path = dlg.GetPath()
self.loadProcess(path)
dlg.Destroy()
self.setStatus("", 0)
self.setlog("")
def loadProcess(self, path):
f = gzip.open(path, 'rb')
leneeg = _pickle.load(f)
EEGs = []
for i in range(leneeg):
EEGs.append(_pickle.load(f))
module = self.treeLoad(f)
self.project = _pickle.load(f)
self.project.EEGS = EEGs
self.moduleManager.modules.root.children = []
self.moduleManager.CreateTree(module.children[0])
self.moduleManager.project = self.project
f.close()
self.node.setOrientation(val, self.node.getOrientation().x, self.node.getOrientation().y, self.node.getOrientation().z)
elif item.text(0) == "X":
self.node.setOrientation(self.node.getOrientation().w, val, self.node.getOrientation().y, self.node.getOrientation().z)
elif item.text(0) == "Y":
self.node.setOrientation(self.node.getOrientation().w, self.node.getOrientation().x, val, self.node.getOrientation().z)
elif item.text(0) == "Z":
self.node.setOrientation(self.node.getOrientation().w, self.node.getOrientation().x, self.node.getOrientation().y, val)
elif parent.text(0) == "Scale":
if item.text(0) == "X":
self.node.setScale(val, self.node.getScale().y, self.node.getScale().z)
elif item.text(0) == "Y":
self.node.setScale(self.node.getScale().x, val, self.node.getScale().z)
elif item.text(0) == "Z":
self.node.setScale(self.node.getScale().x, self.node.getScale().y, val)
elif parent.text(0) == "Attenuation":
light = ModuleManager.extractLight(self.node)
if item.text(0) == "range":
light.setAttenuation(val, light.getAttenuationConstant(), light.getAttenuationLinear(), light.getAttenuationQuadric())
elif item.text(0) == "constant":
light.setAttenuation(light.getAttenuationRange(), val, light.getAttenuationLinear(), light.getAttenuationQuadric())
elif item.text(0) == "linear":
light.setAttenuation(light.getAttenuationRange(), light.getAttenuationConstant(), val, light.getAttenuationQuadric())
elif item.text(0) == "quadratic":
light.setAttenuation(light.getAttenuationRange(), light.getAttenuationConstant(), light.getAttenuationLinear(), val)
elif parent.text(0) == "Spotlightrange":
light = ModuleManager.extractLight(self.node)
if item.text(0) == "inner":
light.setSpotlightInnerAngle(og.Degree(val))
elif item.text(0) == "outer":
light.setSpotlightOuterAngle(og.Degree(val))
elif item.text(0) == "falloff":
def onItemChanged(self, item, column):
if self.valueBeforeEdit is not None and self.valueBeforeEdit != item.text(column):
parent = item.parent()
if parent is None: # handle properties that don't expand here
if item.text(0) == "Name":
if self.node.getName().startswith("entity_"):
if not self.sceneManager.hasEntity(str(item.text(column))):
newEnt = self.node.getAttachedObject(0).clone(str(item.text(column)))
oldEnt = self.node.getAttachedObject(0)
self.node.detachObject(oldEnt)
self.sceneManager.destroyEntity(oldEnt)
self.node.attachObject(newEnt)
# update the selection object since it still has references to the deleted entity
self.so.entity = newEnt
self.so.entityName = newEnt.getName()
else:
item.setText(column, self.valueBeforeEdit)
print "Error: Name already exists!"
elif self.node.getName().startswith("light_"):
if not self.sceneManager.hasLight(str(item.text(column))):
newLight = self.sceneManager.createLight(str(item.text(column)))
oldLight = ModuleManager.extractLight(self.node)
self.node.detachObject(oldLight)
self.node.attachObject(newLight)
newLight.setType(oldLight.getType())
newLight.setVisibilityFlags(newLight.getVisibilityFlags())
newLight.setCastShadows(oldLight.getCastShadows())
newLight.setDiffuseColour(oldLight.getDiffuseColour())
newLight.setSpecularColour(oldLight.getSpecularColour())
newLight.setAttenuation(oldLight.getAttenuationRange(), oldLight.getAttenuationConstant(), oldLight.getAttenuationLinear(), oldLight.getAttenuationQuadric())
if newLight.getType() == og.Light.LT_SPOTLIGHT:
newLight.setSpotlightRange(oldLight.getSpotlightInnerAngle(), oldLight.getSpotlightOuterAngle(), oldLight.getSpotlightFalloff())
if newLight.getType() == og.Light.LT_SPOTLIGHT or newLight.getType() == og.Light.LT_DIRECTIONAL:
newLight.setDirection(oldLight.getDirection())
self.sceneManager.destroyLight(oldLight)
else:
item.setText(column, self.valueBeforeEdit)
print "Error: Name already exists!"
elif item.text(0) == "Zone Name":
self.node.getAttachedObject(0).getUserObject().parentZone.name = str(item.text(column))
elif item.text(0) == "GameObject Id":
if not self.gocManager.inWorldIdExists(str(item.text(column))):
val = None
try:
val = int(item.text(1))
except ValueError, e:
item.setText(column, self.valueBeforeEdit)
print "ValueError: " + str(e)
return
self.node.getAttachedObject(0).getUserObject().inWorldId = str(val)
else:
item.setText(column, self.valueBeforeEdit)
print "Error: Id exists already!"
elif item.text(0) == "Static Geometry Group":
val = None
try:
val = int(item.text(1))
except ValueError, e:
item.setText(column, self.valueBeforeEdit)
print "ValueError: " + str(e)
return
elif item.text(0) == "Rendering Distance":
val = None
try:
val = float(item.text(1))
except ValueError, e:
item.setText(column, self.valueBeforeEdit)
print "ValueError: " + str(e)
return
self.node.getAttachedObject(0).getUserObject().renderingdistance = val
def showProperties(self, so):
# onItemChanged should only be called when the user changes values not when they change by code
self.disconnect(self.treeWidget, SIGNAL("itemChanged (QTreeWidgetItem *,int)"),
self.onItemChanged)
self.so=so
self.treeWidget.clear()
name = so.entity.getParentNode().getName()
self.node = so.entity.getParentNode()
if name.startswith("entity_"):
item = QTreeWidgetItem(self.treeWidget)
item.setText(0, "Name")
n = self.node.getAttachedObject(0).getName()
item.setText(1, n)
item.setFlags(item.flags() | Qt.ItemIsEditable)
itemMat = QTreeWidgetItem(self.treeWidget)
itemMat.setText(0, "Materials")
i = 0
while i < self.node.getAttachedObject(0).getNumSubEntities():
it = QTreeWidgetItem(itemMat)
it.setFlags(item.flags() | Qt.ItemIsEditable)
it.setText(0, "SubMesh" + str(i))
it.setText(1, self.node.getAttachedObject(0).getSubEntity(i).getMaterialName())
i += 1
self.parsePosition(self.node)
self.parseOrientation(self.node)
self.parseScale(self.node)
self.parseEntityOptions(self.node)
elif name.startswith("gameobject_"):
item = QTreeWidgetItem(self.treeWidget)
item.setText(0, "ClassName")
n = str(self.node.getAttachedObject(0).getUserObject().gocName)
item.setText(1, n)
item.setFlags(item.flags() | Qt.ItemIsEditable)
item = QTreeWidgetItem(self.treeWidget)
item.setText(0, "GameObject Id")
n = str(self.node.getAttachedObject(0).getUserObject().inWorldId)
item.setText(1, n)
item.setFlags(item.flags() | Qt.ItemIsEditable)
item = QTreeWidgetItem(self.treeWidget)
item.setText(0, "State")
n = str(self.node.getAttachedObject(0).getUserObject().state)
item.setText(1, n)
self.parsePosition(self.node)
self.parseOrientation(self.node)
self.parseScale(self.node)
propDict = self.node.getAttachedObject(0).getUserObject().propertieDict
item = QTreeWidgetItem(self.treeWidget)
item.setText(0, "Properties")
item.setText(1, str(len(propDict)))
for key in propDict:
propParent = QTreeWidgetItem(item)
propParent.setText(0, "Name")
propParent.setText(1, propDict[key].name)
propItem = QTreeWidgetItem(propParent)
propItem.setText(0, "Name")
propItem.setText(1, propDict[key].name)
propItem.setFlags(propItem.flags() | Qt.ItemIsEditable)
propItem = QTreeWidgetItem(propParent)
propItem.setText(0, "Type")
propItem.setText(1, propDict[key].type)
propItem = QTreeWidgetItem(propParent)
propItem.setText(0, "Data")
propItem.setText(1, propDict[key].data)
propItem.setFlags(propItem.flags() | Qt.ItemIsEditable)
elif name.startswith("light_"):
item = QTreeWidgetItem(self.treeWidget)
light = ModuleManager.extractLight(self.node)
n = light.getName()
item.setText(0, "Name")
item.setText(1, n)
item.setFlags(item.flags() | Qt.ItemIsEditable)
item = QTreeWidgetItem(self.treeWidget)
item.setText(0, "Type")
if light.getType() == og.Light.LT_POINT:
item.setText(1, "point")
elif light.getType() == og.Light.LT_SPOTLIGHT:
item.setText(1, "spot")
elif light.getType() == og.Light.LT_DIRECTIONAL:
item.setText(1, "directional")
item = QTreeWidgetItem(self.treeWidget)
item.setText(0, "Visibility")
item.setText(1, str(light.getVisible()))
item = QTreeWidgetItem(self.treeWidget)
item.setText(0, "CastShadows")
item.setText(1, str(light.getCastShadows()))
if light.getType() == og.Light.LT_POINT or light.getType() == og.Light.LT_SPOTLIGHT:
self.parsePosition(self.node)
if light.getType() == og.Light.LT_SPOTLIGHT:
self.parseSpotLightProperties(self.node)
self.parseDiffuseColor(self.node)
self.parseSpecularColor(self.node)
self.parseLightAttenuation(self.node)
elif name.startswith("area_"):
area = so.entity.getUserObject()
item = QTreeWidgetItem(self.treeWidget)
item.setText(0, "Zone Name")
item.setText(1, area.parentZone.name)
item.setFlags(item.flags() | Qt.ItemIsEditable)
item = QTreeWidgetItem(self.treeWidget)
item.setText(0, "Type")
item.setText(1, area.type)
item = QTreeWidgetItem(self.treeWidget)
item.setText(0, "Dbg Area Id:")
item.setText(1, str(area.id))
item = QTreeWidgetItem(self.treeWidget)
item.setText(0, "Dbg Area Entity Name:")
item.setText(1, area.areaEntity.getName())
item = QTreeWidgetItem(self.treeWidget)
item.setText(0, "Subtract")
item.setText(1, str(area.subtract))
self.parsePosition(area.areaNode)
self.parseOrientation(area.areaNode)
self.parseScale(area.areaNode)
self.connect(self.treeWidget, SIGNAL("itemChanged (QTreeWidgetItem *,int)"),
self.onItemChanged)
def parseSpecularColor(self, node):
item = QTreeWidgetItem(self.treeWidget)
item.setText(0, "Specular Color")
color = ModuleManager.extractLight(self.node).getSpecularColour()
item.setText(1, str(int(255 * color.r)) + "; " + str(int(255 * color.g)) + "; " + str(int(255 * color.b)))
def send(user, password, pincode, cfInviante, pIva, cufficio, module,
files_path, test):
# estrae info da codice ufficio
(cregione, casl, cssa) = cufficio.split('-')
# inizializza cifrario
crypt = Encrypter.PEMCert('resources/SanitelCF.cer')
print('\nParsing receipts')
# carica modulo selezionato e parsa scontrini
documentiSpesa = ModuleManager.importStructure(module).parse(files_path)
# genera file XML
doc730 = Precompilata.Schema730(cregione, casl, cssa, pIva, cfInviante)
doc730.addSpese(documentiSpesa)
xml = doc730.toXML(crypt)
############ SEND SOAP CLIENT ##################
wsdlInfo = {
'invio':
'resources/wsdl/WS_AsincronoInvioDati730/InvioTelematicoSpeseSanitarie730p.wsdl',
'esito':
'resources/wsdl/WS_Ricevute/EsitoInvio/EsitoInvioDatiSpesa730Service.wsdl',
'errore':
'resources/wsdl/WS_Ricevute/DettaglioErrori-CSV/DettaglioErrori730Service.wsdl',
'ricevuta':
'resources/wsdl/WS_Ricevute/RicevutoPDF/RicevutaPdf730Service.wsdl'
}
if (test):
server_domain = 'invioSS730pTest.sanita.finanze.it'
https_verify = False
else:
server_domain = 'invioSS730p.sanita.finanze.it'
https_verify = True
client = SOAP.Client(user=user,
password=password,
domain=server_domain,
wsdl=wsdlInfo,
https_verify=https_verify)
print('\nSending receipts...')
# invia il file XML al sistema TS
success, extra = client.sendFile(cregione, casl, cssa, cfInviante, pincode,
xml, crypt)
if (success):
# attende elaborazione
print('\nWaiting results', end='')
while not client.isElaborationDone(extra):
print('.', end='', flush=True)
time.sleep(5)
# mostra esito
printEsito(client.getInfoEsito(extra))
protocollo = client.getProtocollo(extra)
print('\nWriting results')
# ottiene il dettagli degli errori
csv = client.getErroriCSV(extra)
if csv is not None:
csv_path = 'ricevute/errori_' + protocollo + '.csv'
print('Scrivo errori nel file: ' + csv_path)
writeFile(csv_path, csv)
# ottiene la ricevuta in pdf
pdf = client.getRicevutaPDF(extra)
if pdf is not None:
pdf_path = 'ricevute/ricevuta_' + protocollo + '.pdf'
print('Scrivo ricevuta nel file: ' + pdf_path)
writeFile(pdf_path, pdf)
else:
print(extra)
def parse_cli():
parser = ArgumentParser(
description='** Sistema Tessera Sanitaria Client **')
subparser = parser.add_subparsers(dest='subparser_name')
cliParser = subparser.add_parser(
'send', help='Starts program from command line interface')
cliParser.add_argument('-u',
'--username',
required=True,
metavar='A9AZOS61',
help='Username of Sistema Tessera Sanitaria')
cliParser.add_argument('-p',
'--password',
required=True,
metavar='Salve123',
help='Password of Sistema Tessera Sanitaria')
cliParser.add_argument('-pc',
'--pincode',
required=True,
metavar='5485370458',
help='Pincode of Sistema Tessera Sanitaria')
cliParser.add_argument('-cf',
'--codice-fiscale',
required=True,
metavar='PROVAX00X00X000Y',
help='Your codice fiscale')
cliParser.add_argument('-pi',
'--partita-iva',
required=True,
metavar='98765432104',
help='Your partita iva')
cliParser.add_argument('-cu',
'--codice-ufficio',
required=True,
metavar='604-120-010011',
help='Codice ufficio')
cliParser.add_argument('-m',
'--module',
required=True,
choices=ModuleManager.listStructures(),
help='Structure module of receipts to parse')
cliParser.add_argument(
'-f',
'--files-path',
required=True,
help='Directory path containing month folders of receipts')
testParser = subparser.add_parser('test',
help='Send receipts using test server')
testParser.add_argument('-m',
'--module',
required=True,
choices=ModuleManager.listStructures(),
help='Structure module of receipts to parse')
testParser.add_argument(
'-f',
'--files-path',
required=True,
help='Directory path containing month folders of receipts')
args = parser.parse_args()
if args.subparser_name:
return args
else:
parser.print_help()
return None
def setUp(self): self.mm = ModuleManager(OpenRTM_aist.Properties(defaults_str=configsample_spec))
class TestModuleManager(unittest.TestCase):
def setUp(self):
self.mm = ModuleManager(OpenRTM_aist.Properties(defaults_str=configsample_spec))
def tearDown(self):
del self.mm
def test_load_unload(self):
try:
path = os.getcwd()
self.mm.load(path+"/hoge.py","echo")
self.mm.unload(path+"/hoge.py")
self.mm.load("hoge","echo")
self.mm.unload("hoge")
self.mm.load("hoge.py","echo")
self.mm.unload("hoge.py")
self.mm.load("./hoge.py","echo")
self.mm.unload("./hoge.py")
# Failure Pattern
#self.mm.load("sample")
except:
print "exception."
return
def test_unloadAll(self):
self.mm.unloadAll()
return
def test_symbol(self):
path = os.getcwd()
self.mm.load(path+"/hoge.py","echo")
self.mm.symbol(path+"/hoge.py","echo")()
self.mm.unload(path+"/hoge.py")
self.mm.load("hoge","echo")
self.mm.symbol("hoge","echo")()
self.mm.unload("hoge")
self.mm.load("hoge.py","echo")
self.mm.symbol("hoge.py","echo")()
self.mm.unload("hoge.py")
def test_setLoadpath(self):
self.mm.setLoadpath(["/usr/lib/python/site-packages"])
return
def test_getLoadPath(self):
self.mm.setLoadpath(["/usr/lib/python/site-packages"])
self.assertEqual(self.mm.getLoadPath()[0],"/usr/lib/python/site-packages")
return
def test_addLoadpath(self):
self.mm.setLoadpath(["/usr/lib/python/site-packages"])
self.mm.addLoadpath(["/usr/local/lib/python/site-packages"])
self.assertEqual(self.mm.getLoadPath()[0],"/usr/lib/python/site-packages")
self.assertEqual(self.mm.getLoadPath()[1],"/usr/local/lib/python/site-packages")
return
def test_getLoadedModules(self):
self.mm.load("hoge","echo")
self.assertNotEqual(self.mm.getLoadedModules()[0],None)
return
def test_allowAbsolutePath(self):
self.mm.allowAbsolutePath()
return
def test_disallowAbsolutePath(self):
self.mm.disallowAbsolutePath()
return
def test_allowModuleDownload(self):
self.mm.allowModuleDownload()
return
def test_disallowModuleDownload(self):
self.mm.disallowModuleDownload()
return
def test_findFile(self):
self.assertEqual(self.mm.findFile("hoge",["."]),"hoge")
self.assertEqual(self.mm.findFile("hoge.py",["."]),"hoge.py")
self.assertEqual(self.mm.findFile("hogehoge",["."]),"")
return
def test_fileExist(self):
self.assertEqual(self.mm.fileExist("hoge.py"),True)
self.assertEqual(self.mm.fileExist("./hoge.py"),True)
self.assertEqual(self.mm.fileExist("hoge"),True)
self.assertEqual(self.mm.fileExist("./hoge"),True)
self.assertEqual(self.mm.fileExist("hogehoge"),False)
return
def test_getInitFuncName(self):
self.mm.getInitFuncName("hoge.py")
return
def test_getRtcProfile(self):
self.assertNotEqual(self.mm._ModuleManager__getRtcProfile("./ConfigSample.py").size(),0)
self.assertNotEqual(self.mm._ModuleManager__getRtcProfile("ConfigSample.py").size(),0)
self.assertNotEqual(self.mm._ModuleManager__getRtcProfile("ConfigSample").size(),0)
return
def test_getLoadableModules(self):
self.mm.setLoadpath([".","./","../"])
self.assertNotEqual(self.mm.getLoadableModules(),[])
return
