class UI_EditorEquationAssignment(QtWidgets.QMainWindow): def __init__(self): QtWidgets.QMainWindow.__init__(self) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.ontology_name = getOntologyName(task="task_entity_generation") self.ontology_dir = DIRECTORIES[ "ontology_location"] % self.ontology_name self.ontology_file = FILES["ontology_file"] % self.ontology_name checkAndFixResources(self.ontology_name, stage="ontology_stage_2") self.ontology_container = OntologyContainer(self.ontology_name) self.ontology_tree = self.ontology_container.ontology_tree self.interfaces = self.ontology_container.interfaces self.variables = self.ontology_container.variables # readVariables() self.indices = self.ontology_container.indices self.incidence_dictionary, self.inv_incidence_dictionary = makeIncidenceDictionaries( self.variables) self.equation_dictionary = {} self.__makeEquationDictionary() self.equation_assignment = self.ontology_container.equation_assignment self.radio_selectors = {} self.current_component = None # node or arc self.current_equation_IDs = { } # hash: radio button index value: equation_ID_str self.current_node_network = None self.previous_node_network = None self.current_node_variable_class = None self.selected_node_key = None self.current_node_equation = None self.current_arc_network = None self.previous_arc_network = None self.current_arc_variable_class = None self.selected_arc_key = None self.current_arc_equation = None self.current_interface_network = None self.previous_interface_network = None self.current_interface_variable_class = None self.selected_interface_key = None self.current_interface_equation = None self.node_indicator_item = None self.last_node_coordinate = None self.arc_indicator_item = None self.last_arc_coordinate = None self.intra_indicator_item = None self.last_interface_coordinate = None self.inter_indicator_item = None self.last_inter_coordinate = None self.node_table_objects = {} self.arc_table_objects = {} self.intra_table_objects = {} self.inter_table_objects = {} # icons self.icons = { "edit": QtGui.QIcon("%s/edit.png" % DIRECTORIES["icon_location"]), "OK": QtGui.QIcon("%s/accept.png" % DIRECTORIES["icon_location"]), "back": QtGui.QIcon("%s/back.png" % DIRECTORIES["icon_location"]), "left": QtGui.QIcon("%s/left-icon.png" % DIRECTORIES["icon_location"]), } self.__makeEmptyDataStructures() def __makeEquationDictionary(self): for var_ID in self.variables: for eq_ID in self.variables[var_ID]["equations"]: self.equation_dictionary[eq_ID] = ( var_ID, self.variables[var_ID]["equations"][eq_ID]) def __makeEmptyDataStructures(self): empty_equation_assignment = EquationAssignment() object_keys_networks = self.ontology_container.object_key_list_networks object_keys_intra = self.ontology_container.object_key_list_intra object_keys_inter = self.ontology_container.object_key_list_inter # get already defined assignments for object in object_keys_networks + object_keys_intra + object_keys_inter: empty_equation_assignment[object] = set() if object in self.equation_assignment: empty_equation_assignment[object] = self.equation_assignment[ object] self.equation_assignment = empty_equation_assignment self.node_table_objects = self.__makeTable( "node", self.ui.tableNodes, self.ontology_container.object_key_list_networks) self.arc_table_objects = self.__makeTable( "arc", self.ui.tableArcs, self.ontology_container.object_key_list_networks) self.intra_table_objects = self.__makeTable( "intra", self.ui.tableIntrafaces, self.ontology_container.object_key_list_intra) self.inter_table_objects = self.__makeTable( "inter", self.ui.tableInterfaces, self.ontology_container.object_key_list_inter) def __makeTable(self, what, ui_table, object_list): """ generate tables """ t = ui_table row = t.rowCount() selector = {} # RULE: the object key is a tuple with the second element indicating what it is (node, arce, intra, inter) for object in object_list: if what == object[1]: t.setRowCount(row + 1) column = 0 for item in object: if item != what: self.__setItem(t, row, column, item) column += 1 selector[row] = object item = self.__setItem(t, row, column, "edit", icon=self.icons["edit"]) row += 1 self.__resize(t) return selector def __resize(self, tab): tab.resizeColumnsToContents() t = self.__tabSizeHint(tab) x = t.width() s = QtCore.QSize() s.setWidth(x) s.setHeight(tab.height()) tab.resize(s) def __tabSizeHint(self, tab): width = 0 for i in range(tab.columnCount()): width += tab.columnWidth(i) width += tab.verticalHeader().sizeHint().width() width += tab.verticalScrollBar().sizeHint().width() width += tab.frameWidth() * 2 height = 0 for i in range(tab.rowCount()): height += tab.rowHeight(i) height += tab.horizontalHeader().sizeHint().height() height += tab.horizontalScrollBar().sizeHint().width() height += tab.frameWidth() * 2 return QtCore.QSize(width, min(height, MAX_HEIGHT)) def __setItem(self, table_widget, row, col, text, icon=None): item = QtWidgets.QTableWidgetItem() if icon: item.setIcon(icon) item.setTextAlignment(QtCore.Qt.AlignHCenter) else: item.setText(text) table_widget.setItem(row, col, item) item.setFlags(QtCore.Qt.ItemIsEnabled) return item def __hideRadioSelectors(self, selector_list): for s in selector_list: if s in self.radio_selectors: self.radio_selectors[s].hide() def __showRadioSelectors(self, selector_list): for s in selector_list: if s in self.radio_selectors: self.radio_selectors[s].show() def __makeAndAddRadioSelector(self, group_name, what, receiver, index, layout, autoexclusive=True): radio_selector = RadioSelector() list_of_choices = [] counter = 0 clearLayout(layout) layout.addWidget(radio_selector) for item in what: list_of_choices.append( (str(counter), item, receiver)) # token is the string of the counter counter += 1 radio_selector.addListOfChoices(group_name, list_of_choices, index, autoexclusive=autoexclusive) return radio_selector def __makeNodeVariableClassList(self): # RULE: only those that apply to the current network var_class_list = sorted( self.ontology_tree[self.current_node_network]["behaviour"]["node"]) # RULE: first variables must be port variable if self.equation_assignment[self.selected_node_key] == set(): var_class_list_with_port_variables = self.ontology_container.rules[ "variable_classes_having_port_variables"] var_classes = sorted( set(var_class_list).intersection( set(var_class_list_with_port_variables))) else: var_classes = var_class_list self.ui.comboBoxNodeVariableClasses.clear() self.ui.comboBoxNodeVariableClasses.addItems(var_classes) def __makeArcVariableClassList(self): var_class_list = self.ontology_tree[ self.current_arc_network]["behaviour"]["arc"] self.ui.comboBoxArcVariableClasses.clear() self.ui.comboBoxArcVariableClasses.addItems(var_class_list) def __makeInterfaceVariableClassList(self): interface_record_def = Interface(None, None, None, self.current_interface_variable_class) var_class_list = interface_record_def["internal_variable_classes"] self.ui.comboBoxInterfacesVariableClasses.clear() self.ui.comboBoxInterfacesVariableClasses.addItems(var_class_list) def __makeEquationList(self): equation_list = {} for eq_ID in self.equation_dictionary: var_ID, equation = self.equation_dictionary[eq_ID] # print(var_ID, eq_ID, equation) if self.current_node_network == equation["network"]: var_class = self.variables[var_ID]["type"] if var_class == "state": equation_list[eq_ID] = (var_ID, var_class, equation["rhs"]) for eq_ID in equation_list: print(eq_ID, " -- ", equation_list[eq_ID]) if len(equation_list) > 0: rendered_expressions = {} radio_item_list = [] self.inverse_dictionary = {} # hash: label, value: (var_ID, eq_ID) for eq_ID in equation_list: rendered_expressions[ eq_ID] = renderExpressionFromGlobalIDToInternal( equation_list[eq_ID][2], self.variables, self.indices) var_ID = equation_list[eq_ID][0] rendered_variable = self.variables[ equation_list[eq_ID][0]]["aliases"]["internal_code"] print(rendered_variable, rendered_expressions[eq_ID]) s = "%s := %s" % (rendered_variable, rendered_expressions[eq_ID]) radio_item_list.append(s) self.inverse_dictionary[s] = (var_ID, eq_ID) self.radio = UI_RadioSelector(radio_item_list, [], allowed=1) self.radio.setWindowTitle("select one") self.radio.rejected.connect(self.__gotState) self.radio.exec_() def __gotState(self): list = self.radio.getMarked() var_ID, eq_ID = self.inverse_dictionary[list[0]] print("debugging -- exited", list, var_ID, eq_ID) var_equ_tree = DotGraphVariableEquations(self.variables, self.indices, var_ID, self.ontology_name) print("debugging -- dotgrap done") buddies = set() for var_ID in var_equ_tree.tree.IDs: o, str_ID = var_ID.split("_") ID = int(str_ID) if o == "variable": network = self.variables[ID]['network'] if network in self.ontology_container.list_leave_networks: buddies.add((ID, network)) # print("debugging --", network) # print("debugging -- buddies", self.buddies) nw, component, dynamics, nature, token = self.selected_node_key node_object = TEMPLATE_NODE_OBJECT % (dynamics, nature) self.ontology_container.equation_assignment[node_object] = { "tree": var_equ_tree.tree.tree, "IDs": var_equ_tree.tree.IDs, "nodes": var_equ_tree.tree.nodes, "buddies": buddies } print("debugging -- end of buddies") # # # def makeTree(self, var_eq_tree, parent_var_ID, d_equs, var_ID): # """ # interate to find all equations and variables # :tree: bipartite var/eq tree # :param d_equs: set of equations to be deleted - list of IDs (integers) # :param var_ID: variable ID (integer) # :return: None # """ # # for eq_id in self.inv_incidence_dictionary[var_ID]: # if eq_id not in d_equs: # d_equs.append(eq_id) # equ_node_ID = var_eq_tree.addNode("equation", parent_var_ID) # var_node_ID = var_eq_tree.addNode("variable", equ_node_ID) # lhs, incidence_list = self.incidence_dictionary[eq_id] # self.makeTree(var_eq_tree, var_node_ID, d_equs, lhs) # # def workTree(self, var_ID): # d_equs = [] # set() # # # - key: equation_ID(integer) # # - value: (lhs - variable_ID, rhs - incidence list (integers) ) # # self.incidence_dictionary, self.inv_incidence_dictionary = self.makeIncidenceDictionaries() # self.reduceVars(d_equs, var_ID) # # d_equs_text = "" # for eq_ID in d_equs: # lhs, incidence_list = self.incidence_dictionary[eq_ID] # rhs = self.variables[lhs]["equations"][eq_ID]["rhs"] # rhs_rendered = renderExpressionFromGlobalIDToInternal(rhs, variables=self.variables, indices=self.indices) # lhs_rendered = self.variables[lhs]["aliases"]["internal_code"] # d_equs_text += "\n%s :: %s := %s" % (eq_ID, lhs_rendered, rhs_rendered) # return d_equs, d_equs_text # # def reduceVars(self, d_equs, var_ID): # """ # interate to find all equations and variables to be deleted # in most of the cases everything is deleted except the state variables # because the equations are all dependent on each other. # :param inv_incidence_dictionary: "inverse" incidence dictionary # :param variables: variables (dictionary) # :param incidence_dictionary: incidence dictionary (var, incidence list) # :param d_vars: set of variables to be deleted - list of IDs (integers) # :param d_equs: set of equations to be deleted - list of IDs (integers) # :param var_ID: variable ID (integer) # :return: None # """ # # for eq_id in self.inv_incidence_dictionary[var_ID]: # if eq_id not in d_equs: # d_equs.append(eq_id) # lhs, incidence_list = self.incidence_dictionary[eq_id] # self.reduceVars(d_equs, lhs) # def makeIncidenceDictionaries(self): # """ # variables may be defined by several equations # # :param variables: variable dictionary with integrated equation dictionary # :param expression_network: network on which the expression is defined # :return: incidence_dictionary # - key: equation_ID (integer) # - value: (lhs-variable_ID, rhs-incidence list (integers) ) # inverse incidence matrix as dictionary # - key : variable ID (integer) # - value: list of equations (integer) # """ # incidence_dictionary = {} # # inv_incidence_dictionary_ = {v: set() for v in self.variables.keys()} # inv_incidence_dictionary = {v: [] for v in self.variables.keys()} # for v in self.variables: # try: # equations = self.variables[v].equations # variables as class Variables # except: # equations = self.variables[v]["equations"] # variables from variable dict, the variable file format # for e in equations: # if e in [97, 63]: # print("debugging", e) # inc_list = equations[e]["incidence_list"] # self.makeIncidentList(equations[e]["rhs"]) # # c_ = copy(inc_list) # # c__ = copy(inc_list) # incidence_dictionary[e] = (v, inc_list) # inv_incidence_dictionary[v].append(inc_list) # # # for i in inc_list: # # inv_incidence_dictionary_[int(i)].add(e) # # equations[e]["incidence_list"] = c__ # # # inv_incidence_dictionary = {} # # for v in inv_incidence_dictionary # # inv_incidence_dictionary[v] = sorted(list(inv_incidence_dictionary_[var_ID])) # # return incidence_dictionary, inv_incidence_dictionary # def makeIncidentList(self, equation_ID_coded_string): # """ # make incidence list for a ID-coded expression # extracts all variables into a list # :param equation_ID_coded_string: # :return: sorted incidence list of variable IDs [integers # """ # incidence_list = [] # splited = equation_ID_coded_string.split(ID_spacer) # for i in splited: # test_string = ID_spacer + i # # print("debugging", test_string, ID_delimiter["variable"]) # if test_string[0:2] == ID_delimiter["variable"][0:2]: # inc = i.strip(ID_delimiter["variable"]) # incidence_list.append(inc) # return sorted(set(incidence_list)) def __resetEquation(self): self.radio_selectors["equations"].uncheckGroup("equations") def __makeEquations(self, variable_class, selection, autoexclusive=True): self.current_equation_IDs = {} index = 1 equations = [M_None] self.current_equation_IDs[0] = None indices = self.ontology_container.indices equation_ID_list = [] for var_ID in self.variables: var = self.variables[var_ID] if var["network"] == self.current_node_network: if var["type"] == variable_class: lhs = var["label"] for eq_ID in var["equations"]: equ = var["equations"][eq_ID] if equ["network"] == self.current_node_network: expression = equ["rhs"] rhs = renderExpressionFromGlobalIDToInternal( expression, self.variables, indices) entry = "%s %s = %s" % (eq_ID, lhs, rhs) equations.append(entry) self.current_equation_IDs[index] = eq_ID index += 1 # eqs = self.variables[var_ID]["equations"] #["equation_list"] # equation_ID_list.extend(eqs) # for ID in equation_ID_list: # lhs = self.equations[ID]["lhs"] # rhs = self.equations[ID]["rhs"] # entry = "%s %s = %s" % (ID, lhs, rhs) # equations.append(entry) # self.current_equation_IDs[index] = ID # index += 1 # self.radio_selectors["equations"] = self.__makeAndAddRadioSelector("equations", # equations, # self.radioReceiverEquations, # selection, # self.ui.horizontalLayoutEquations, # autoexclusive=autoexclusive) # # self.radio_selectors["equations"].show() # self.ui.groupBoxEquations.show() def on_tableNodes_cellPressed(self, row, column): column = self.ui.tableNodes.columnCount() - 1 self.node_indicator_item = self.__setItem(self.ui.tableNodes, row, column, "", icon=self.icons["left"]) if self.last_node_coordinate: last_row, last_column = self.last_node_coordinate self.__setItem(self.ui.tableNodes, last_row, last_column, "", icon=self.icons["edit"]) self.last_node_coordinate = row, column self.current_component = "node" self.previous_node_network = self.current_node_network self.selected_node_key = self.node_table_objects[row] self.current_node_network = self.selected_node_key[0] self.__makeEquationList() # self.__makeNodeVariableClassList() # # self.current_node_variable_class = self.ui.comboBoxNodeVariableClasses.currentText() def on_tableArcs_cellPressed(self, row, column): column = self.ui.tableArcs.columnCount() - 1 self.arc_indicator_item = self.__setItem(self.ui.tableArcs, row, column, "", icon=self.icons["left"]) if self.last_arc_coordinate: last_row, last_column = self.last_arc_coordinate self.__setItem(self.ui.tableArcs, last_row, last_column, "", icon=self.icons["edit"]) self.last_arc_coordinate = row, column self.current_component = "arc" self.previous_arc_network = self.current_arc_network self.selected_arc_key = self.arc_table_objects[row] self.current_arc_network = self.selected_arc_key[0] self.__makeArcVariableClassList() self.current_arc_variable_class = self.ui.comboBoxArcVariableClasses.currentText( ) def on_tableInterfaces_cellPressed(self, row, column): column = self.ui.tableInterfaces.columnCount() - 1 self.inter_indicator_item = self.__setItem(self.ui.tableInterfaces, row, column, "", icon=self.icons["left"]) if self.last_inter_coordinate: last_row, last_column = self.last_inter_coordinate self.__setItem(self.ui.tableInterfaces, last_row, last_column, "", icon=self.icons["edit"]) self.last_inter_coordinate = row, column self.current_component = "inter" self.previous_interface_network = self.current_interface_network self.selected_interface_key = self.inter_table_objects[row] self.current_interface_network = self.selected_interface_key[0] self.__makeInterfaceVariableClassList() self.current_inface_variable_class = self.ui.comboBoxInterfacesVariableClasses.currentText( ) # @QtCore.pyqtSignature("int") def on_tabWidget_currentChanged(self, index): # print("index: ", index) if index == 0: self.current_component = "node" self.ui.groupBoxEquations.hide() elif index == 1: self.current_component = "arc" self.ui.groupBoxEquations.hide() elif index == 2: self.current_component = "interface" self.ui.groupBoxEquations.hide() else: print(">>>>> tab change -- something went wrong") def on_pushNodeSave_pressed(self): print("write file") self.ontology_container.writeMe() def on_pushArcSave_pressed(self): print("write file") self.ontology_container.writeMe() def on_pushInterfaceSave_pressed(self): print("write file") self.ontology_container.writeMe() # @QtCore.pyqtSignature('QString') def on_comboBoxNodeVariableClasses_currentIndexChanged(self, index): # print("debugging got node class entry :", entry) entry = self.ui.comboBoxNodeVariableClasses.currentText() self.current_node_variable_class = entry self.__makeEquations(entry, -1) # @QtCore.pyqtSignature('QString') def on_comboBoxArcVariableClasses_currentIndexChanged(self, index): entry = self.ui.comboBoxArcVariableClasses() print(" got arc class entry :", entry) self.current_arc_variable_class = entry self.__makeEquations(entry, -1) # @QtCore.pyqtSignature('QString') def on_comboBoxInterfacesVariableClasses_currentIndexChanged(self, index): entry = self.ui.comboBoxInterfacesVariableClasses.currentText() print(" got interface class entry :", entry) self.current_interface_variable_class = entry self.__makeEquations(entry, -1, autoexclusive=False) def radioReceiverEquations(self, group_name, index_str, equation_index, logical_value): index = int(index_str) # print("radioReceiverEquations :", group_name, index, equation_index, logical_value) self.current_equation = self.current_equation_IDs[ index] # equation_index if self.current_component == "node": key = self.selected_node_key if index == 0: variable_class = M_None equation = -1 else: variable_class = self.current_node_variable_class equation = self.current_equation self.equation_assignment[key].add(equation) print("debugging") elif self.current_component == "arc": key = self.selected_arc_key if index == 0: variable_class = M_None equation = -1 else: variable_class = self.current_arc_variable_class equation = self.current_equation self.equation_assignment["arc"][ key] = self.current_arc_network, equation # print("arc :", self.equation_assignment["arc"]) self.arc_items[self.last_arc_item[0], 5].setText(str(equation)) self.arc_items[self.last_arc_item[0], 3].setText(variable_class) self.__resize(self.ui.tableArcs) elif self.current_component == "interface": key = self.selected_interface_key else: print(" no such component:", self.current_component)
class UI_EditorEquationAssignment(QtGui.QMainWindow): # potential_issues : TODO : is the order important. Adding a network does leave us unordered compared to the old # approach....??? def __init__(self): QtGui.QMainWindow.__init__(self) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.ontology_name = getOntologyName(task="task_entity_generation") self.ontology_dir = DIRECTORIES[ "ontology_location"] % self.ontology_name self.ontology_file = FILES["ontology_file"] % self.ontology_name checkAndFixResources(self.ontology_name, stage="ontology_stage_2") self.ontology_container = OntologyContainer(self.ontology_name) self.ontology_tree = self.ontology_container.ontology_tree self.interfaces = self.ontology_container.interfaces self.variables = self.ontology_container.variables # readVariables() self.incidence_dictionary, self.inv_incidence_dictionary = makeIncidenceDictionaries( self.variables) self.equation_dictionary = self.ontology_container.equation_dictionary # self.__makeEquationDictionary() self.equation_assignment = self.ontology_container.equation_assignment self.radio_selectors = {} self.current_component = None # node or arc self.current_equation_IDs = { } # hash: radio button index value: equation_ID_str self.current_node_network = None self.previous_node_network = None self.current_node_variable_class = None self.selected_node_key = None self.current_node_equation = None self.current_arc_network = None self.previous_arc_network = None self.current_arc_variable_class = None self.selected_arc_key = None self.current_arc_equation = None self.current_interface_network = None self.previous_interface_network = None self.current_interface_variable_class = None self.selected_interface_key = None self.current_interface_equation = None self.node_indicator_item = None self.last_node_coordinate = None self.arc_indicator_item = None self.last_arc_coordinate = None self.intra_indicator_item = None self.last_interface_coordinat = None self.inter_indicator_item = None self.last_inter_coordinate = None self.node_table_objects = {} self.arc_table_objects = {} self.intra_table_objects = {} self.inter_table_objects = {} # icons self.icons = { "edit": QtGui.QIcon("%s/edit.png" % DIRECTORIES["icon_location"]), "OK": QtGui.QIcon("%s/accept.png" % DIRECTORIES["icon_location"]), "back": QtGui.QIcon("%s/back.png" % DIRECTORIES["icon_location"]), "left": QtGui.QIcon("%s/left-icon.png" % DIRECTORIES["icon_location"]), } self.ui.groupBoxEquations.hide() self.__makeEmptyDataStructures() # def __makeEquationDictionary(self): # for var_ID in self.variables: # for eq_ID in self.variables[var_ID]["equations"]: # self.equation_dictionary[eq_ID] = self.variables[var_ID]["equations"][eq_ID] def __makeEmptyDataStructures(self): empty_equation_assignment = EquationAssignment() object_keys_networks = self.ontology_container.object_key_list_networks object_keys_intra = self.ontology_container.object_key_list_intra object_keys_inter = self.ontology_container.object_key_list_inter # get already defined assignments for object in object_keys_networks + object_keys_intra + object_keys_inter: empty_equation_assignment[object] = set() if object in self.equation_assignment: empty_equation_assignment[object] = self.equation_assignment[ object] self.equation_assignment = empty_equation_assignment # # self.node_table_objects = self.__makeTable("node", self.ui.tableNodes, # self.ontology_container.object_key_list_networks) # self.arc_table_objects = self.__makeTable("arc", self.ui.tableArcs, # self.ontology_container.object_key_list_networks) # self.intra_table_objects = self.__makeTable("intra", self.ui.tableIntrafaces, # self.ontology_container.object_key_list_intra) # self.inter_table_objects = self.__makeTable("inter", self.ui.tableInterfaces, # self.ontology_container.object_key_list_inter) def __makeTable(self, what, ui_table, object_list): """ generate tables """ t = ui_table row = t.rowCount() selector = {} # RULE: the object key is a tuple with the second element indicating what it is (node, arce, intra, inter) for object in object_list: if what == object[1]: t.setRowCount(row + 1) column = 0 for item in object: if item != what: self.__setItem(t, row, column, item) column += 1 selector[row] = object item = self.__setItem(t, row, column, "edit", icon=self.icons["edit"]) row += 1 self.__resize(t) return selector def __resize(self, tab): tab.resizeColumnsToContents() t = self.__tabSizeHint(tab) x = t.width() s = QtCore.QSize() s.setWidth(x) s.setHeight(tab.height()) tab.resize(s) def __tabSizeHint(self, tab): width = 0 for i in range(tab.columnCount()): width += tab.columnWidth(i) width += tab.verticalHeader().sizeHint().width() width += tab.verticalScrollBar().sizeHint().width() width += tab.frameWidth() * 2 height = 0 for i in range(tab.rowCount()): height += tab.rowHeight(i) height += tab.horizontalHeader().sizeHint().height() height += tab.horizontalScrollBar().sizeHint().width() height += tab.frameWidth() * 2 return QtCore.QSize(width, min(height, MAX_HEIGHT)) def __setItem(self, table_widget, row, col, text, icon=None): item = QtGui.QTableWidgetItem() if icon: item.setIcon(icon) item.setTextAlignment(QtCore.Qt.AlignHCenter) else: item.setText(text) table_widget.setItem(row, col, item) item.setFlags(QtCore.Qt.ItemIsEnabled) return item def __hideRadioSelectors(self, selector_list): for s in selector_list: if s in self.radio_selectors: self.radio_selectors[s].hide() def __showRadioSelectors(self, selector_list): for s in selector_list: if s in self.radio_selectors: self.radio_selectors[s].show() def __makeAndAddRadioSelector(self, group_name, what, receiver, index, layout, autoexclusive=True): radio_selector = RadioSelector() list_of_choices = [] counter = 0 clearLayout(layout) layout.addWidget(radio_selector) for item in what: list_of_choices.append( (str(counter), item, receiver)) # token is the string of the counter counter += 1 radio_selector.addListOfChoices(group_name, list_of_choices, index, autoexclusive=autoexclusive) return radio_selector def __makeNodeVariableClassList(self): # RULE: only those that apply to the current network var_class_list = sorted( self.ontology_tree[self.current_node_network]["behaviour"]["node"]) # RULE: first variables must be port variable if self.equation_assignment[self.selected_node_key] == set(): var_class_list_with_port_variables = self.ontology_container.rules[ "variable_classes_having_port_variables"] var_classes = sorted( set(var_class_list).intersection( set(var_class_list_with_port_variables))) else: var_classes = var_class_list self.ui.comboBoxNodeVariableClasses.clear() self.ui.comboBoxNodeVariableClasses.addItems(var_classes) def __makeArcVariableClassList(self): var_class_list = self.ontology_tree[ self.current_arc_network]["behaviour"]["arc"] self.ui.comboBoxArcVariableClasses.clear() self.ui.comboBoxArcVariableClasses.addItems(var_class_list) def __makeInterfaceVariableClassList(self): interface_record_def = Interface(None, None, None, self.current_interface_variable_class) var_class_list = interface_record_def["internal_variable_classes"] self.ui.comboBoxInterfacesVariableClasses.clear() self.ui.comboBoxInterfacesVariableClasses.addItems(var_class_list) def __makeEquationList(self): pass def __resetEquation(self): self.radio_selectors["equations"].uncheckGroup("equations") def __makeEquations(self, variable_class, selection, autoexclusive=True): self.current_equation_IDs = {} index = 1 equations = [M_None] self.current_equation_IDs[0] = None indices = self.ontology_container.indices equation_ID_list = [] for var_ID in self.variables: var = self.variables[var_ID] if var["network"] == self.current_node_network: if var["type"] == variable_class: lhs = var["label"] for eq_ID in var["equations"]: equ = var["equations"][eq_ID] if equ["network"] == self.current_node_network: expression = equ["rhs"] rhs = renderExpressionFromGlobalIDToInternal( expression, self.variables, indices) entry = "%s %s = %s" % (eq_ID, lhs, rhs) equations.append(entry) self.current_equation_IDs[index] = eq_ID index += 1 # eqs = self.variables[var_ID]["equations"] #["equation_list"] # equation_ID_list.extend(eqs) # for ID in equation_ID_list: # lhs = self.equations[ID]["lhs"] # rhs = self.equations[ID]["rhs"] # entry = "%s %s = %s" % (ID, lhs, rhs) # equations.append(entry) # self.current_equation_IDs[index] = ID # index += 1 self.radio_selectors["equations"] = self.__makeAndAddRadioSelector( "equations", equations, self.radioReceiverEquations, selection, self.ui.horizontalLayoutEquations, autoexclusive=autoexclusive) self.radio_selectors["equations"].show() self.ui.groupBoxEquations.show() def on_tableNodes_cellPressed(self, row, column): column = self.ui.tableNodes.columnCount() - 1 self.node_indicator_item = self.__setItem(self.ui.tableNodes, row, column, "", icon=self.icons["left"]) if self.last_node_coordinate: last_row, last_column = self.last_node_coordinate self.__setItem(self.ui.tableNodes, last_row, last_column, "", icon=self.icons["edit"]) self.last_node_coordinate = row, column self.current_component = "node" self.previous_node_network = self.current_node_network self.selected_node_key = self.node_table_objects[row] self.current_node_network = self.selected_node_key[0] self.__makeNodeVariableClassList() self.current_node_variable_class = self.ui.comboBoxNodeVariableClasses.currentText( ) def on_tableArcs_cellPressed(self, row, column): column = self.ui.tableArcs.columnCount() - 1 self.arc_indicator_item = self.__setItem(self.ui.tableArcs, row, column, "", icon=self.icons["left"]) if self.last_arc_coordinate: last_row, last_column = self.last_arc_coordinate self.__setItem(self.ui.tableArcs, last_row, last_column, "", icon=self.icons["edit"]) self.last_arc_coordinate = row, column self.current_component = "arc" self.previous_arc_network = self.current_arc_network self.selected_arc_key = self.arc_table_objects[row] self.current_arc_network = self.selected_arc_key[0] self.__makeArcVariableClassList() self.current_arc_variable_class = self.ui.comboBoxArcVariableClasses.currentText( ) def on_tableInterfaces_cellPressed(self, row, column): column = self.ui.tableInterfaces.columnCount() - 1 self.inter_indicator_item = self.__setItem(self.ui.tableInterfaces, row, column, "", icon=self.icons["left"]) if self.last_inter_coordinate: last_row, last_column = self.last_inter_coordinate self.__setItem(self.ui.tableInterfaces, last_row, last_column, "", icon=self.icons["edit"]) self.last_inter_coordinate = row, column self.current_component = "inter" self.previous_interface_network = self.current_interface_network self.selected_interface_key = self.inter_table_objects[row] self.current_interface_network = self.selected_interface_key[0] self.__makeInterfaceVariableClassList() self.current_inface_variable_class = self.ui.comboBoxinterfaceVariableClasses.currentText( ) @QtCore.pyqtSignature("int") def on_tabWidget_currentChanged(self, index): # print("index: ", index) if index == 0: self.current_component = "node" self.ui.groupBoxEquations.hide() elif index == 1: self.current_component = "arc" self.ui.groupBoxEquations.hide() elif index == 2: self.current_component = "interface" self.ui.groupBoxEquations.hide() else: print(">>>>> tab change -- something went wrong") def on_pushNodeSave_pressed(self): print("write file") self.ontology_container.writeMe() def on_pushArcSave_pressed(self): print("write file") self.ontology_container.writeMe() def on_pushInterfaceSave_pressed(self): print("write file") self.ontology_container.writeMe() @QtCore.pyqtSignature('QString') def on_comboBoxNodeVariableClasses_currentIndexChanged(self, entry): # print("debugging got node class entry :", entry) self.current_node_variable_class = entry self.__makeEquations(entry, -1) @QtCore.pyqtSignature('QString') def on_comboBoxArcVariableClasses_currentIndexChanged(self, entry): print(" got arc class entry :", entry) self.current_arc_variable_class = entry self.__makeEquations(entry, -1) @QtCore.pyqtSignature('QString') def on_comboBoxInterfaceVariableClasses_currentIndexChanged(self, entry): print(" got interface class entry :", entry) self.current_interface_variable_class = entry self.__makeEquations(entry, -1, autoexclusive=False) def radioReceiverEquations(self, group_name, index_str, equation_index, logical_value): index = int(index_str) # print("radioReceiverEquations :", group_name, index, equation_index, logical_value) self.current_equation = self.current_equation_IDs[ index] # equation_index if self.current_component == "node": key = self.selected_node_key if index == 0: variable_class = M_None equation = -1 else: variable_class = self.current_node_variable_class equation = self.current_equation self.equation_assignment[key].add(equation) print("debugging") elif self.current_component == "arc": key = self.selected_arc_key if index == 0: variable_class = M_None equation = -1 else: variable_class = self.current_arc_variable_class equation = self.current_equation self.equation_assignment["arc"][ key] = self.current_arc_network, equation # print("arc :", self.equation_assignment["arc"]) self.arc_items[self.last_arc_item[0], 5].setText(str(equation)) self.arc_items[self.last_arc_item[0], 3].setText(variable_class) self.__resize(self.ui.tableArcs) elif self.current_component == "interface": key = self.selected_interface_key else: print(" no such component:", self.current_component)