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())
