def activate_test_tab(self): slosl_model = self.slosl_model() statement_names = sorted(s.name for s in slosl_model.statements) combobox = self.test_view_select_combobox old_selection = qstrpy( combobox.currentText() ) combobox.clear() strlist = QStringList() for name in statement_names: strlist.append(name) combobox.insertStringList(strlist) try: current = statement_names.index(old_selection) except ValueError: if statement_names: current = 0 else: current = -1 combobox.setCurrentItem(current)
def dropped(self, data): source = data.source() if source is None: return listview = self.listView() if source == listview: item = source.currentItem() if item == self or self.hasParent(item): self.setStatus(self.tr('Drop aborted, invalid target.')) return if isinstance(item, PredefContainerItem) and self._accepts_child_class(ContainerItem): self.insertItem( item.new_reference(self) ) self.setOpen(True) elif self._accepts_child_class(item.__class__): self.moveChild(item) self.setOpen(True) elif source.name() == 'node_attribute_list': model = self.model item = source.currentItem() if hasattr(item, 'text'): name = qstrpy( item.text() ) if not name: return access_name = self.build_access_name(name, model) new_model = buildMessageElement(model, 'attribute', readable_name=qstrpy(self.tr('Attribute')), type_name=name, access_name=access_name) item = AttributeContentItem(self.editor, self, new_model) self.setOpen(True) else: self.setStatus('DROP from %s' % source.name())
def __run_test(self, test_call): if self.__running: self.__stop_test() self.__running = True current_test = self.test_view_select_combobox.currentText() if current_test: current_test = qstrpy(current_test) if not current_test: self.__setStatus(self.__tr("Please select a view to test")) return slosl_model = self.slosl_model() statement = slosl_model.getStatement(current_test) if statement: attribute_model = self.attribute_model() init_code = qstrpy(self.test_init_code.text()) graphviz_program = self.test_graphviz_program_combobox.currentText() if graphviz_program: graphviz_program = qstrpy(graphviz_program) else: graphviz_program = 'neato' try: t = time() result_graph = test_call([statement], attribute_model, init_code) t = time() - t result = self.__build_svg(result_graph, graphviz_program) self.test_view_graph.set_image_data(result) self.__setStatus(self.__tr('Generated graph in %1 seconds.').arg(round(t,2))) except Exception, e: self.__setStatus(e)
def slosl_foreach_apply_button_clicked(self): name = qstrpy(self.slosl_foreach_varname.text()).strip() declaration = qstrpy(self.slosl_foreach_values.text()).strip() try: tree = str_to_mathdom(declaration, 'slosl_foreach_list') except ParseException, e: self.slosl_foreach_varname.setFocus() self.slosl_foreach_varname.selectAll() self.__setStatus(e) return
def language_name_activated(self, language): if self._selected_language: self._code_dict[self._selected_language] = qstrpy( self.init_code.text() ) language = qstrpy(language).lower() self._selected_language = language try: code = pyqstr( self._code_dict[language] ) except KeyError: self.init_code.clear() else: self.init_code.setText(code)
def accept(self): model = self._model field_names = self._active_fields() if 'language_name' in field_names and self._selected_language: self._code_dict[self._selected_language] = qstrpy( self.init_code.text() ) class_name = None if 'class_name' in field_names: value = self.class_name.currentText() validator = self.class_name_validator if validator.validate(value, 0)[0] == validator.Acceptable: if value not in self.class_name: self.class_name.insertItem(value) class_name = qstrpy(value) else: self.class_name.setFocus() return for attrname, fieldname in self.FIELD_MAP: try: field = getattr(self, fieldname) except AttributeError: continue if field.isHidden(): continue if isinstance(field, QListBox): values = [ qstrpy(field.text(i)) for i in range(field.count()) ] setattr(model, attrname, values) else: if isinstance(field, QComboBox): value = field.currentText() else: value = field.text() setattr(model, attrname, qstrpy(value)) if hasattr(model, 'codes'): del model.codes for language, code in self._code_dict.iteritems(): if not code.strip(): continue model.setCode(language, code, class_name) if class_name and not model.codes: model.setCode('python', None, class_name) self.GUI_CLASS.accept(self) self._edsm_editor.edsm_model_updated(model)
def copy_type_to_model(self): all_types = self._all_type_names() type_name = qstrpy(self.type_name_field.text()).strip() if not type_name: self.__setStatus(self.__tr('Missing type name')) self.type_name_field.setFocus() return None def tag_name(element_type): if element_type in ALL_TYPES: namespace = SQL_NAMESPACE_URI else: namespace = DB_NAMESPACE_URI return u"{%s}%s" % (namespace, element_type) base_type = qstrpy(self.attribute_type_select.currentText()) child_type = None if self.attribute_type_subtype_frame.isEnabled(): child_type = qstrpy(self.attribute_type_subtype_select.currentText()) value_dict = {u'type_name' : type_name} if self.attribute_type_length_frame.isEnabled(): if self.attribute_type_length_checkbox.isChecked(): attribute = self.__LENGTH_ATTRIBUTES[base_type] value = self.attribute_type_length.value() if attribute == 'maxval': value = 1 << value value_dict[attribute] = unicode(value) self.__custom_data_types.delType(type_name) model = etree.SubElement(self.__custom_data_types, tag_name(base_type), value_dict) composite_table = self.attribute_type_composite_table if child_type: etree.SubElement(model, tag_name(child_type)) elif composite_table.isEnabled(): for row in xrange(composite_table.numRows()): cname = qstrpy( composite_table.text(row, 0) ) ctype = qstrpy( composite_table.item(row, 1).currentText() ) if cname and ctype: if ctype == type_name or ctype not in all_types: self.__setStatus(self.__tr('Invalid type selected: %1').arg(ctype)) composite_table.setFocus() composite_table.selectRow(row) return etree.SubElement(model, tag_name(ctype), access_name=cname) self.__setStatus() return model
def __reset_iconview(self, iconview, subgraph_model, static_state_names): editor = self._edsm_editor tr = self.tr pixmaps = self._pixmaps default_pixmap = pixmaps['state'] class SpecialStateIcon(IconViewStateIcon): MODIFIABLE=False def __init__(self, model): pixmap = pixmaps.get(model.name, default_pixmap) IconViewStateIcon.__init__(self, iconview, editor, model, pixmap) self.setRenameEnabled(False) iconview.reset_connections() static_items = {} y_pos = 10 for state_name in static_state_names: readable_name = qstrpy( tr(state_name) ) model = subgraph_model.getStateByName(state_name) if model is None: model = buildState(subgraph_model.states, state_name, readable_name) elif not model.readable_name: model.readable_name = readable_name item = SpecialStateIcon(model) item.move(10, y_pos) static_items[state_name] = item y_pos += 50 iconview.reset_static_states(static_items) self.state_nr = 0
def setStatus(self, *args): strings = [] append = strings.append for arg in args: if isinstance(arg, unicode): append(arg) elif isinstance(arg, str): append(unicode(arg)) elif isinstance(arg, qt.QString): append(qstrpy(arg)) elif isinstance(arg, Exception): self.logger.exception(arg) exc_type = arg.__class__.__name__ try: arg = arg.args[0] except (AttributeError, IndexError): arg = unicode(arg) append( u" %s: %s" % (exc_type, arg) ) else: append(unicode(arg)) line = u' '.join(strings) statusbar = self.statusBar() if line: statusbar.message(line) else: statusbar.clear()
def fileOpen(self): filename = qt.QFileDialog.getOpenFileName( qt.QString.null, self.FILE_FILTER, self, 'open file dialog', self.tr('Open file ...')) filename = qstrpy(filename) if filename: self.loadFile(filename)
def exportFlat(self): try: xslt = STYLESHEETS['flat_export'] except KeyError: self.setStatus(self.tr("Stylesheet 'flat_export' not installed.")) filename = qt.QFileDialog.getSaveFileName( None, self.FLAT_FILE_FILTER, self, 'export file dialog', self.tr('Export to flat file ...')) filename = qstrpy(filename) if not filename: return if not filename.endswith(self.FLAT_FILE_EXTENSION): filename += self.FLAT_FILE_EXTENSION result = xslt.apply(self.current_tree) if not self.preferences.optimize_xml_size: indent = STYLESHEETS.get('indent') if indent: result = indent.apply(result) xslt = indent xml_string = xslt.tostring(result) self.__backup_file(filename) try: xml_file = open(filename, 'w') except Exception, e: self.setStatus(self.tr('Opening file for writing failed:'), e) return
def slosl_foreach_remove_button_clicked(self): itemlist = self.slosl_foreach_list item = itemlist.selectedItem() if item: name = qstrpy(item.text(0)) itemlist.clearSelection() itemlist.takeItem(item) self.__model.delForeach(name)
def setText(self, name): pyname = qstrpy(name) if pyname in self.__FIXED_NAMES: return self._model.readable_name = pyname QIconViewItem.setText(self, name) self.set_popup_title(name) self._edsm_editor.edsm_model_updated(self._model)
def __run_test(self, test_call): if self.__running: self.__stop_test() self.__store_current_code() self.__running = True init_code = None if self.__current_test: init_code = self.__tests.getTestCode(self.__current_test) if not init_code: self.__setStatus(self.__tr("Please select a test case")) return current_view = qstrpy(self.test_view_select_combobox.currentText()) if not current_view: self.__setStatus(self.__tr("Please select a view to test")) return slosl_model = self.slosl_model() statement = slosl_model.getStatement(current_view) if statement: attribute_model = self.attribute_model() graphviz_program = self.test_graphviz_program_combobox.currentText() if graphviz_program: graphviz_program = qstrpy(graphviz_program) else: graphviz_program = 'neato' try: t = time() views = test_call([statement], attribute_model, init_code) t_views = time() - t t = time() result_graph = ViewGraph(views).graph result = self.__build_svg(result_graph, graphviz_program) t_graph = time() - t self.test_view_graph.set_image_data(result) self.__setStatus(self.__tr( 'Generated views in %1 seconds, graph in %1 seconds.' ).arg(round(t_views,2)).arg(round(t_graph,2))) except Exception, e: self.__setStatus(e)
def setText(self, column, text): text = qstrpy(text).strip() model = self.__model if column == 0: self._set_coltext1(text) else: self._set_coltext2(text) qt.QListViewItem.setText(self, column, text)
def add_or_replace_node_attribute_clicked(self): a_name = qstrpy(self.node_attribute_name.text()) if not a_name: self.node_attribute_name.setFocus() return a_type = qstrpy(self.node_attribute_type.currentText()) if not a_type: self.node_attribute_type.setFocus() return attribute = buildAttribute(self._attribute_descriptions, a_name, a_type) attribute_list = self.node_attribute_list list_item = attribute_list.findItem(a_name, 0) if list_item: list_item.setText(1, a_type) else: self._build_attribute_list_item(attribute)
def test_view_select_activated(self, view_name): view_name = qstrpy(view_name) self.__store_current_code() self.__current_test = view_name test_code = self.__view_tests.get(view_name) if not test_code: test_code = DEFAULT_CODE self.test_init_code.setText(pyqstr(test_code))
def slosl_foreach_list_selectionChanged(self): self.slosl_enable_buttons() item = self.slosl_foreach_list.selectedItem() if item: self.__current_foreach_entry = name = qstrpy(item.text(0)) entry = self.__model.getForeach(name) declaration = entry and entry.serialize('slosl_foreach_list') or "" # FIXME: bug, handle inconsistent view/model somewhere?? self.slosl_foreach_varname.setText(name) self.slosl_foreach_values.setText(declaration)
def activate_test_tab(self): test_cases = sorted(test.name for test in self.__tests.test_list) self.__resetCombobox(self.test_select_combobox, test_cases) self.__current_test = qstrpy(self.test_select_combobox.currentText()) statement_names = sorted(s.name for s in self.slosl_model().statements) self.__resetCombobox(self.test_view_select_combobox, statement_names) test_code = self.__tests.getTestCode(self.__current_test) self.test_init_code.setText(pyqstr(test_code))
def node_attribute_type_activated(self, name): name = qstrpy(name) if name in ALL_TYPES: return model = self.__custom_data_types.getType(name) base_type = model.base_type self.type_name_field.setText(name) self.attribute_type_select.setCurrentText(base_type) self.copy_type_from_model(base_type, model)
def copy_to_model(self): model = self.__model for attribute, value in model: try: field = getattr(self, attribute) except AttributeError: continue if isinstance(field, QCheckBox): value = field.isChecked() elif isinstance(field, QButton): value = field.isDown() elif isinstance(field, QLineEdit): value = qstrpy( field.text() ) elif isinstance(field, QTextEdit): value = filter(None, (s.strip() for s in qstrpy(field.text()).split('\n'))) else: raise TypeError, "unsupported field type: %s" % type(field) setattr(model, attribute, value)
def fileSaveAs(self): filename = qt.QFileDialog.getSaveFileName( None, self.FILE_FILTER, self, 'save file dialog', self.tr('Save to file ...')) filename = qstrpy(filename) if not filename: return if not filename.endswith(self.FILE_EXTENSION): filename += self.FILE_EXTENSION self.setCurrentFile(filename, self.current_tree) self.fileSave()
def setCurrentFile(self, filename, tree=None): if tree is None: tree = etree.ElementTree( buildFile(self._xml_parser) ) self.current_tree = tree self.current_file = filename self.fileSaveAction.setEnabled( bool(filename) ) caption = qstrpy( self.caption() ).split(self.TITLE_SPLITTER)[-1] if filename: basename = os.path.basename(filename) basename = os.path.splitext(basename)[0] if basename: caption = '%s%s%s' % (basename, self.TITLE_SPLITTER, caption) self.setCaption(caption)
def attribute_type_remove_clicked(self): name = qstrpy(self.type_name_field.text()) if name in ALL_TYPES: self.__setStatus(self.tr("Cannot remove builtin type.")) elif name in [ a.type_name for a in self._attribute_descriptions.itervalues() ]: self.__setStatus(self.tr("Cannot remove types used in attributes.")) else: self.__custom_data_types.delType(name) type_list = self.node_attribute_type get_text = type_list.text for row in range(type_list.count()): if get_text(row) == name: type_list.removeItem(row) break self.type_name_field_textChanged(name)
def __resetCombobox(self, combobox, lines): old_selection = qstrpy( combobox.currentText() ) combobox.clear() strlist = QStringList() for line in lines: strlist.append(line) combobox.insertStringList(strlist) try: current = lines.index(old_selection) except ValueError: if lines: current = 0 else: current = -1 combobox.setCurrentItem(current)
def copy_slosl_to_model(self, model=None): if model is None: model = self.__model def to_term(term_str, term_type='infix_term'): term = str_to_mathdom(term_str, term_type) return term.getroot() current_field = None try: old_name = str(model.view) current_field = self.slosl_view_name model.view = qstrpy(self.slosl_view_name.text()).strip() current_field = self.slosl_from parents = filter(None, (name.strip() for name in qstrpy(self.slosl_from.text()).split(','))) if parents: model.parents = parents else: self.__setStatus("Parent view names missing.") return self.slosl_from current_field = self.slosl_attribute_select attributes = qstrpy(self.slosl_attribute_select.text()).strip() del model.selects add = model.setSelect for attribute in attributes.split('\n'): try: name, value = attribute.split('=', 1) except ValueError: name, value = attribute.split('.', 1)[-1], attribute add(name, to_term(value)) current_field = self.slosl_rank_expression ranking_function_name = qstrpy(self.slosl_rank_function.currentText()).strip() if ranking_function_name: ranked = model.ranked ranked.function = ranking_function_name for i, field in islice( enumerate( (self.slosl_rank_count, self.slosl_rank_expression, self.slosl_rank_compare) ), ranked.function_parameter_count() ): ranked.setParameter(i, to_term(qstrpy(field.text()))) else: del model.ranked current_field = self.slosl_with with = qstrpy(self.slosl_with.text()).strip() del model.withs
def __setup_icons(self): listview = self.message_listview item = self.__orig_items = listview.firstChild() items = [] while item: items.append(item) item = item.firstChild() MessageItem.PROTOCOLS_PIXMAP = items[0].pixmap(0) MessageItem.PROTOCOLS_NAME = items[0].text(0) for item, item_class in izip(islice(items, 1, None), chain(self.__TOP_LEVEL_CLASSES, self.__ITEM_CLASSES)): pixmap = item_class.PIXMAP = item.pixmap(0) name = item_class.READABLE_NAME = qstrpy( item.text(0) ) if item_class == ContainerItem: ContainerRefItem.PIXMAP = pixmap ContainerRefItem.READABLE_NAME = name ContainerItem.REF_ITEM_CLASS = ContainerRefItem ContainerItem.REF_MODEL_TYPE = ContainerRefItem.MODEL_TYPE listview.takeItem(self.__orig_items) # remove icons from listview but keep reference
def remove_node_attribute_clicked(self): selected_attribute = self.node_attribute_list.selectedItem() if selected_attribute: name = qstrpy( selected_attribute.text() ) self._attribute_descriptions.delAttribute(name) self.node_attribute_list.takeItem(selected_attribute)
def setModel(self, dialog_model): self._model = dialog_model self.activate_fields() self._code_dict.clear() self._selected_language = None for attrname, (field, label) in self.field_dict.iteritems(): try: value = getattr(dialog_model, attrname) except AttributeError: continue if isinstance(field, QComboBox): field.setCurrentText(value) elif isinstance(field, QListBox): field.clear() for line in sorted(value): field.insertItem(pyqstr(line)) else: field.setText(value) for queue_type in ('to', 'from'): try: field = getattr(self, "%s_queue" % queue_type) state = getattr(dialog_model, "%s_state" % queue_type) selected = getattr(dialog_model, "%s_queue" % queue_type, None) queues = getattr(state, queue_type == 'to' and 'input_queues' or 'output_queues') except AttributeError: continue field.clear() for i, queue in enumerate(sorted(queues)): field.insertItem(pyqstr(queue)) if selected: field.setCurrentText(selected) if hasattr(self, 'class_name'): self.class_name.setCurrentItem(-1) if hasattr(self, 'language_name'): self.language_name.setCurrentItem(-1) if hasattr(self, 'init_code'): self.init_code.clear() if hasattr(dialog_model, 'codes'): field = self.language_name lower_values = set(qstrpy(s).lower() for s in field) for code in dialog_model.codes: language = code.language if language and language not in lower_values: field.insertItem(pyqstr(language.capitalize())) codes = dialog_model.codes self._code_dict.update( (c.language, c.code) for c in codes if c.language ) for code in codes: if code.class_name: self.class_name.setCurrentText(pyqstr(code.class_name)) break if codes: code = codes[0] for language in self.language_name: if qstrpy(language).lower() == code.language: self._selected_language = code.language self.language_name.setCurrentText(language) self.init_code.setText(pyqstr(code.code or '')) break
def name(self): return qstrpy(self.text())