Merge branch 'master' of https://github.com/hANSIc99/Pythonic

Author: hANSIc99

CHANGES.txt

@@ -1,3 +1,8 @@
+0.12
+
+    Now five independent grids per Pythonic instance
+    Jumping between grid possible (basic return element)
+
 0.11
 
     REST element implemented

dist/Pythonic-0.12.tar.gz

@@ -5,7 +5,7 @@
 
 setuptools.setup(
         name = 'Pythonic',
-        version = '0.11',
+        version = '0.12',
         author = 'Stephan Avenwedde',
         author_email = '[email protected]',
         license = 'GPLv3',

setup.py

@@ -0,0 +1,88 @@
+from PyQt5.QtWidgets import QFrame, QHBoxLayout
+from PyQt5.QtCore import Qt, QMimeData, QDir, pyqtSignal
+from PyQt5.QtGui import QDrag, QPixmap
+from PyQt5.QtCore import QCoreApplication as QC
+from Pythonic.mastertool import MasterTool
+import logging
+
+class BasicTools(QFrame):
+
+    reg_tool = pyqtSignal(tuple, name='register_tool_basic')
+
+    def __init__(self, parent):
+        super().__init__(parent)
+        self.initUI()
+
+    def initUI(self):
+
+        self.setStyleSheet('background-color: silver')
+        image_folder = QDir('images')
+
+        self.layout_h = QHBoxLayout()
+
+        self.op_tool = MasterTool(self, 'ExecOp', 1)
+        self.op_tool.setPixmap(QPixmap('images/ExecOp.png').scaled(120, 60))
+
+        self.branch_tool = MasterTool(self, 'ExecBranch', 2)
+        self.branch_tool.setPixmap(QPixmap('images/ExecBranch.png').scaled(120, 60))
+
+        self.return_tool = MasterTool(self, 'ExecReturn', 0)
+        self.return_tool.setPixmap(QPixmap('images/ExecReturn.png').scaled(120, 60))
+
+        self.proc_tool = MasterTool(self, 'ExecProcess', 2)
+        self.proc_tool.setPixmap(QPixmap('images/ExecProcess.png').scaled(120, 60))
+
+        self.ta_tool = MasterTool(self, 'ExecTA', 1)
+        self.ta_tool.setPixmap(QPixmap('images/ExecTA.png').scaled(120, 60))
+
+        self.sched_tool = MasterTool(self, 'ExecSched', 1)
+        self.sched_tool.setPixmap(QPixmap('images/ExecSched.png').scaled(120, 60))
+
+        self.stack_tool = MasterTool(self, 'ExecStack', 1)
+        self.stack_tool.setPixmap(QPixmap('images/ExecStack.png').scaled(120, 60))
+
+        self.layout_h.addWidget(self.op_tool)
+        self.layout_h.addWidget(self.branch_tool)
+        self.layout_h.addWidget(self.return_tool)
+        self.layout_h.addWidget(self.proc_tool)
+        self.layout_h.addWidget(self.ta_tool)
+        self.layout_h.addWidget(self.sched_tool)
+        self.layout_h.addWidget(self.stack_tool)
+        self.layout_h.addStretch(1)
+
+        self.setLayout(self.layout_h)
+
+    def mousePressEvent(self, event):
+
+        child = self.childAt(event.pos())
+        if not child:
+            return
+
+        mimeData = QMimeData()
+        mimeData.setText(child.type)
+
+        logging.debug('mousePressEvent() called: {}'.format(event.pos()))
+        drag = QDrag(self)
+        drag.setPixmap(child.pixmap())
+        drag.setMimeData(mimeData)
+        drag.setHotSpot(event.pos() - child.pos())
+
+        if drag.exec_(Qt.CopyAction | Qt.MoveAction, Qt.CopyAction) == Qt.MoveAction:
+            child.close()
+        else:
+            child.show()
+            child.setPixmap(child.pixmap())
+
+    def register_tools(self):
+
+        logging.debug('register_tools() called BasicTools')
+        self.reg_tool.emit(self.op_tool.toolData())
+        self.reg_tool.emit(self.branch_tool.toolData())
+        self.reg_tool.emit(self.return_tool.toolData())
+        self.reg_tool.emit(self.proc_tool.toolData())
+        self.reg_tool.emit(self.ta_tool.toolData())
+        self.reg_tool.emit(self.sched_tool.toolData())
+        #uncomment in future release
+        self.reg_tool.emit(self.stack_tool.toolData())
+
+

src/Pythonic/basictools.py

@@ -2,7 +2,7 @@
 from PyQt5.QtCore import Qt, QCoreApplication, pyqtSignal, QVariant
 from PyQt5.QtGui import  QPixmap, QPainter, QColor
 from PyQt5.QtWidgets import (QVBoxLayout, QHBoxLayout, QLabel, QTextEdit, QWidget, QComboBox, QCheckBox,
-                                QPushButton)
+                                QPushButton, QStackedWidget)
 from PyQt5.QtCore import QCoreApplication as QC
 import logging
 import os.path
@@ -17,12 +17,14 @@ class ExecReturn(ElementMaster):
     pixmap_path = 'images/ExecReturn.png'
     child_pos = (False, False)
 
+    query_grid_config = pyqtSignal(name='query_grid_config')
+
     def __init__(self, row, column):
         self.row = row
         self.column = column
 
-        # currentdata, currentindex, ischecked
-        self.config = (None, None, False)
+        # grid, wrk_selecctor_index, wrk_pos, ischecked
+        self.config = (0, 0, (0,0), False)
         super().__init__(self.row, self.column, QPixmap(self.pixmap_path), True, self.config)
         super().edit_sig.connect(self.edit)
         logging.debug('ExecReturn called at row {}, column {}'.format(row, column))
@@ -43,15 +45,19 @@ def __getstate__(self):
     def openEditor(self):
         logging.debug('openEditor() called ExecReturn')
 
+
     def edit(self):
         logging.debug('edit() called ExecReturn')
         self.returnEditLayout = QVBoxLayout()
 
         self.returnEdit = ElementEditor(self)
         self.returnEdit.setWindowTitle(QC.translate('', 'Edit Return'))
 
-        self.top_text = QLabel()
-        self.top_text.setText(QC.translate('', 'Go to element:'))
+        self.grid_text = QLabel()
+        self.grid_text.setText(QC.translate('', 'Go to grid:'))
+
+        self.element_text = QLabel()
+        self.element_text.setText(QC.translate('', 'Go to element:'))
 
         self.help_text = QWidget()
         self.help_text_layout = QVBoxLayout(self.help_text)
@@ -83,17 +89,21 @@ def edit(self):
         self.log_line_layout.addStretch(1)
 
 
-        self.element_selector = QComboBox()
-        self.populateSelector()
+        self.element_selector = QStackedWidget()
+
+        self.grid_selector = QComboBox()
 
-        if self.config[1]:
-            self.element_selector.setCurrentIndex(self.config[1])
-        if self.config[2]:
-            self.log_checkbox.setChecked(True)
+        # emmiting signal
+        self.query_grid_config.emit()
+        self.grid_selector.currentIndexChanged.connect(self.gridIndexChanged)
+
+        self.loadLastConfig()
 
         self.confirm_button.clicked.connect(self.returnEdit.closeEvent)
         self.returnEdit.window_closed.connect(self.edit_done)
-        self.returnEditLayout.addWidget(self.top_text)
+        self.returnEditLayout.addWidget(self.grid_text)
+        self.returnEditLayout.addWidget(self.grid_selector)
+        self.returnEditLayout.addWidget(self.element_text)
         self.returnEditLayout.addWidget(self.element_selector)
         self.returnEditLayout.addWidget(self.log_line)
         self.returnEditLayout.addWidget(self.help_text)
@@ -102,17 +112,41 @@ def edit(self):
         self.returnEdit.setLayout(self.returnEditLayout)
         self.returnEdit.show()
 
-    def populateSelector(self):
+    def baustelle(self, config):
+
+        self.wrk_selectors_arr = []
+
+        logging.debug('ExecReturn::baustelle config: {}'.format(config))
+        for index, wrk_area in enumerate(config):
+            self.grid_selector.addItem('Grid {}'.format(index + 1))
 
-        index = self.parent().returnCurrentElements()
+            self.wrk_selectors_arr.append(QComboBox())
+            self.element_selector.addWidget(self.wrk_selectors_arr[index])
+            for pos in wrk_area:
+                self.wrk_selectors_arr[index].addItem('{} {}'.format(pos[0], alphabet[pos[1]]), QVariant(pos))
 
-        for pos in index:
-            if self.getPos() != pos:
-                self.element_selector.addItem('{} {}'.format(pos[0], alphabet[pos[1]]), QVariant(pos))
+    def gridIndexChanged(self, index):
+
+        logging.debug('ExecReturn::gridIndexChanged() called: {}'.format(index))
+        self.element_selector.setCurrentIndex(index)
+
+
+    def loadLastConfig(self):
+
+        grid, wrk_selecctor_index, wrk_pos, log_state = self.config
+
+        self.grid_selector.setCurrentIndex(grid)
+        self.element_selector.setCurrentIndex(grid)
+        self.wrk_selectors_arr[grid].setCurrentIndex(wrk_selecctor_index)
+        self.log_checkbox.setChecked(log_state)
 
     def edit_done(self):
         logging.debug('edit_done() called ExecReturn' )
-        self.config = (self.element_selector.currentData(), self.element_selector.currentIndex(), self.log_checkbox.isChecked())
+        grid = self.grid_selector.currentIndex()
+        wrk_selecctor_index = self.wrk_selectors_arr[grid].currentIndex()
+        wrk_pos = self.wrk_selectors_arr[grid].currentData()
+
+        self.config = (grid, wrk_selecctor_index, wrk_pos, self.log_checkbox.isChecked())
         self.addFunction(ReturnFunction)
 
 class ReturnFunction(Function):
@@ -122,7 +156,9 @@ def __init__(self, config, b_debug, row, column):
 
     def execute(self, record):
 
-        log_txt = '{{BASIC RETURN}}           Return to {}|{}'.format(self.config[0][0], alphabet[self.config[0][1]])
-        result = Record(self.getPos(), self.config[0], record, log=self.config[2], log_txt=log_txt)
+        grid, wrk_selecctor_index, wrk_pos, log_state = self.config
+        target_0 = (grid, wrk_pos[0], wrk_pos[1])
+        log_txt = '{{BASIC RETURN}} Grid {} - Pos {}|{}'.format(grid, wrk_pos[0], alphabet[wrk_pos[1]])
+        result = Record(self.getPos(), target_0, record, log=log_state, log_txt=log_txt)
         return result
 

src/Pythonic/elements/basic_return.py

@@ -21,13 +21,14 @@ class WorkerSignals(QObject):
 
     finished = pyqtSignal(object, name='element_finished' )
     except_sig = pyqtSignal(object, name='exception')
-    proc_ret = pyqtSignal(object)
+    #proc_ret = pyqtSignal(object)
     pid_sig = pyqtSignal(object)
 
 class GridOperator(QObject):
 
     update_logger   = pyqtSignal(name='update_logger')
     exec_pending    = pyqtSignal(name='exec_pending')
+    switch_grid     = pyqtSignal('PyQt_PyObject', name='switch_grid')
 
     def __init__(self, grid):
         super().__init__()
@@ -42,7 +43,6 @@ def __init__(self, grid):
         self.pending_return = []
         self.pid_register = []
         self.exec_pending.connect(self.checkPending)
-        mp.set_start_method('spawn')
         logging.debug('__init__() GridOperator, threadCount: {}'.format(
             self.threadpool.maxThreadCount()))
 
@@ -162,19 +162,32 @@ def proceedExec(self, prg_return):
 
     def goNext(self, prg_return):
 
+        # check is target_0 includes a diffrent grid 
+        # ExecReturn elemenot
 
         if prg_return.target_0:
             logging.debug('GridOperator::goNext() called with next target_0: {}'.format(prg_return.target_0))
             logging.debug('GridOperator::goNext() called with record_0: {}'.format(prg_return.record_0))
 
             if self.fastpath:
+
+                if len(prg_return.target_0) == 3: # switch grid, go over main
+                    # fastpath = True
+                    self.switch_grid.emit((prg_return, True))
+                    return
 
                 new_rec = self.fastPath(prg_return.target_0, prg_return.record_0)
                 if new_rec: # check for ExecR or ExecRB
                     self.goNext(new_rec)
                 else: # if nothing found: proceed as usual
                     self.startExec(prg_return.target_0, prg_return.record_0)
             else:
+
+                if len(prg_return.target_0) == 3: # switch grid, go over main
+                    # fastpath = False
+                    self.switch_grid.emit((prg_return, False))
+                    return
+
                 self.startExec(prg_return.target_0, prg_return.record_0)
 
         if prg_return.target_1: