class OrderDlg(QDialog):
def __init__(self, parent=None):
super(OrderDlg, self).__init__(parent)
self.create_widgets()
self.layout_widgets()
self.setMinimumWidth(850)
self.setWindowTitle(u'Список Order Item')
def create_widgets(self):
self.model = QtSql.QSqlTableModel(self)
self.model.setTable("OrderItem")
self.model.setEditStrategy(QtSql.QSqlTableModel.OnManualSubmit)
self.model.setSort(ID, Qt.AscendingOrder)
self.model.setHeaderData(ID, Qt.Horizontal, QVariant("Order Item"))
self.model.setHeaderData(ORDER, Qt.Horizontal,
QVariant("Order"))
self.model.setHeaderData(PRODUCT, Qt.Horizontal,
QVariant("Product"))
self.model.select()
self.view = QTableView()
self.view.setModel(self.model)
self.view.resizeColumnsToContents()
def layout_widgets(self):
layout = QVBoxLayout()
layout.addWidget(self.view)
self.setLayout(layout)
def createTable(self):
# create the view
tv = QTableView()
self.param = self.createParam()
# set the delegate to allow editing table entries
self.td = SpinBoxDelegate(self.param.traits.xslot)
tv.setItemDelegate(self.td)
tm = ParamTableModel(self.createParam(), self)
tv.setModel(tm)
# set the minimum size
tv.setMinimumSize(400, 300)
# hide grid
tv.setShowGrid(False)
# set the font
font = QFont("Courier New", 8)
tv.setFont(font)
# hide horizontal header
hh = tv.horizontalHeader()
hh.setVisible(False)
# set vertical header properties
vh = tv.verticalHeader()
#vh.setStretchLastSection(True)
# set column width to fit contents
tv.resizeColumnsToContents()
return tv
class DataFrameWidget(QWidget):
''' a simple widget for using DataFrames in a gui '''
def __init__(self, name='DataFrameTable1', parent=None):
super(DataFrameWidget, self).__init__(parent)
self.name = name
self.dataModel = DataFrameModel()
self.dataModel.setDataFrame(DataFrame())
self.dataTable = QTableView()
self.dataTable.setSelectionBehavior(QAbstractItemView.SelectRows)
self.dataTable.setSortingEnabled(True)
self.dataTable.setModel(self.dataModel)
self.dataModel.signalUpdate()
#self.dataTable.setFont(QFont("Courier New", 8))
layout = QVBoxLayout()
layout.addWidget(self.dataTable)
self.setLayout(layout)
def setFormat(self, fmt):
""" set non-default string formatting for a column """
for colName, f in fmt.iteritems():
self.dataModel.columnFormat[colName] = f
def fitColumns(self):
self.dataTable.horizontalHeader().setResizeMode(QHeaderView.Stretch)
def setDataFrame(self, df):
self.dataModel.setDataFrame(df)
def resizeColumnsToContents(self):
self.dataTable.resizeColumnsToContents()
class MatlForm(QDialog):
def __init__(self):
super(MatlForm, self).__init__()
if 1 == 0:
self.matlModel= QSqlRelationalTableModel(self)
self.matlModel.setTable('matl')
self.matlModel.setHeaderData(0, Qt.Horizontal,QVariant('name'))
self.matlModel.select()
self.matlView= QTableView()
self.matlView.setModel(self.matlModel)
self.matlView.setItemDelegate(MatlDelegate(self))
self.matlView.setSelectionMode(QTableView.SingleSelection)
self.matlView.setSelectionBehavior(QTableView.SelectRows)
self.matlView.resizeColumnsToContents()
self.matlView.layout()
matlViewLabel= QLabel("<font color=green size=72><b> Material Editor </b></font>")
if 1 == 0:
dataLayout= QVBoxLayout()
dataLayout.addWidget(self.matlViewLabel)
dataLayout.addWidget(self.matlView)
self.setLayout(dataLayout)
self.matlPopup.show()
self.matlPropsHere.show()
self.show()
class OrderDlg(QDialog):
def __init__(self, parent=None):
super(OrderDlg, self).__init__(parent)
self.create_widgets()
self.layout_widgets()
self.setMinimumWidth(850)
self.setWindowTitle(u'Список Order Item')
def create_widgets(self):
self.model = QtSql.QSqlTableModel(self)
self.model.setTable("OrderItem")
self.model.setEditStrategy(QtSql.QSqlTableModel.OnManualSubmit)
self.model.setSort(ID, Qt.AscendingOrder)
self.model.setHeaderData(ID, Qt.Horizontal, QVariant("Order Item"))
self.model.setHeaderData(ORDER, Qt.Horizontal, QVariant("Order"))
self.model.setHeaderData(PRODUCT, Qt.Horizontal, QVariant("Product"))
self.model.select()
self.view = QTableView()
self.view.setModel(self.model)
self.view.resizeColumnsToContents()
def layout_widgets(self):
layout = QVBoxLayout()
layout.addWidget(self.view)
self.setLayout(layout)
class DetailedProgressDialog(QDialog):
def __init__(self, parent, states):
super(DetailedProgressDialog, self).__init__(parent)
self.setWindowTitle("Realization Progress")
layout = QGridLayout(self)
self.detailed_progress_widget = DetailedProgress(states, self)
self.overview_label = QLabel("Realizations")
self.single_view = QTableView()
self.single_view.setModel(SingleProgressModel(self.single_view))
self.single_view_label = QLabel("Realization details")
self.detailed_progress_widget.clicked.connect(self.show_selection)
layout.addWidget(self.single_view_label, 0, 0)
layout.addWidget(self.overview_label, 0, 1)
layout.addWidget(self.single_view, 1, 0)
layout.addWidget(self.detailed_progress_widget, 1, 1)
self.detailed_progress_widget.show()
self.setLayout(layout)
self.layout().setColumnStretch(0, 1)
self.layout().setColumnStretch(1, 2)
self.progress = None
self.selected_realization = None
self.resize(parent.width(), parent.height())
def set_progress(self, progress, iteration):
self.progress = progress
self.detailed_progress_widget.set_progress(progress, iteration)
self.overview_label.setText("Realizations for iteration {}".format(iteration))
self.update_single_view()
self.update()
def show_selection(self, iens):
if not self.progress:
return
self.selected_realization = iens
self.single_view_label.setText("Realization id: {}".format(iens))
self.update_single_view()
def update_single_view(self):
if not self.single_view.isVisible() or not self.selected_realization in self.progress:
return
model_data = []
jobs = self.progress[self.selected_realization]
headers = []
for job in jobs:
data = job.dump_data()
row = [str(data[key]) for key in data]
model_data.append(row)
headers = data.keys()
self.single_view.model().update_data(headers, model_data)
self.single_view.resizeColumnsToContents()
self.single_view.model().modelReset.emit()
def createTable(self, header, tabledata):
"""creates a table"""
gridlayout2 = QGridLayout(self)
gridlayout2.setObjectName("gridlayout2")
tableView = QTableView(self)
tableView.setObjectName("tableView")
gridlayout2.addWidget(tableView, 0, 0, 1, 1)
self.__popUp = QMenu(tableView)
self.__copyAction = QAction(self.tr("Copy data"), tableView)
self.connect(self.__copyAction, SIGNAL("triggered()"), self.copy)
self.__popUp.addAction(self.__copyAction)
tableView.setContextMenuPolicy(Qt.CustomContextMenu)
self.connect(tableView, SIGNAL('customContextMenuRequested(QPoint)'),
self.popUpMenu)
# set the table model
tm = TableModel(tabledata, header, self)
tableView.setModel(tm)
tableView.setAlternatingRowColors(True)
# set the minimum size
self.setMinimumSize(400, 300)
# hide grid
tableView.setShowGrid(True)
# set the font
#font = QFont("Courier New", 12)
#self.tableView.setFont(font)
# hide vertical header
vh = tableView.verticalHeader()
vh.setVisible(True)
# set horizontal header properties
hh = tableView.horizontalHeader()
hh.setStretchLastSection(True)
# set column width to fit contents
tableView.resizeColumnsToContents()
tableView.setSortingEnabled(True)
tableView.sortByColumn(0, Qt.AscendingOrder)
# set row height
nrows = len(tabledata)
for row in xrange(nrows):
tableView.setRowHeight(row, 18)
class PositionWindow(QMainWindow):
WA_Maemo5StackedWindow = 127
WA_Maemo5PortraitOrientation = 128
WA_Maemo5LandscapeOrientation = 129
'''
@param transactionModel - TransactionModel
'''
def __init__(self, parent, exchange, ticker, transactionModel):
QMainWindow.__init__(self, parent)
self.prop = MaeMoneyProperties.instance()
self.setupUi(exchange, ticker, transactionModel)
def setupUi(self, exchange, ticker, transactionModel):
self.setWindowTitle("%s:%s" %(exchange, ticker))
widget = QWidget(self)
self.setCentralWidget(widget)
self.layout = QVBoxLayout()
widget.setLayout(self.layout)
self.transactTableView = QTableView(self)
self.transactTableView.setSelectionBehavior(QAbstractItemView.SelectRows)
header = self.transactTableView.horizontalHeader()
header.setResizeMode(QHeaderView.ResizeToContents)
self.transactTableView.setHorizontalHeader(header)
self.transactTableView.setModel(transactionModel)
self.transactTableView.resizeRowsToContents()
self.transactTableView.resizeColumnsToContents()
header.setStretchLastSection(True)
self.layout.addWidget(self.transactTableView)
self.setOrientation()
self.setAttributeAndCatch(self.WA_Maemo5StackedWindow, True)
def setAttributeAndCatch(self, attribute, trueFalse):
try:
self.setAttribute(attribute, trueFalse)
except AttributeError:
qDebug("Can't set attribute %d" %(attribute))
def setOrientation(self):
if self.prop.isPortraitMode():
self.setAttributeAndCatch(self.WA_Maemo5PortraitOrientation, True)
self.setAttributeAndCatch(self.WA_Maemo5LandscapeOrientation, False)
else:
self.setAttributeAndCatch(self.WA_Maemo5LandscapeOrientation, True)
self.setAttributeAndCatch(self.WA_Maemo5PortraitOrientation, False)
class DataFrameWidget(QWidget):
''' a simple widget for using DataFrames in a gui '''
def __init__(self, dataFrame, parent=None):
super(DataFrameWidget, self).__init__(parent)
self.dataModel = DataFrameModel()
self.dataModel.setDataFrame(dataFrame)
self.dataTable = QTableView()
self.dataTable.setModel(self.dataModel)
self.dataModel.signalUpdate()
layout = QVBoxLayout()
layout.addWidget(self.dataTable)
self.setLayout(layout)
def resizeColumnsToContents(self):
self.dataTable.resizeColumnsToContents()
class DataFrameWidget(QWidget):
''' a simple widget for using DataFrames in a gui '''
def __init__(self, dataFrame, parent=None):
super(DataFrameWidget, self).__init__(parent)
self.dataModel = DataFrameModel()
self.dataModel.setDataFrame(dataFrame)
self.dataTable = QTableView()
self.dataTable.setModel(self.dataModel)
self.dataModel.signalUpdate()
layout = QVBoxLayout()
layout.addWidget(self.dataTable)
self.setLayout(layout)
def resizeColumnsToContents(self):
self.dataTable.resizeColumnsToContents()
class DataFrameWidget(QWidget):
''' a simple widget for using DataFrames in a gui '''
def __init__(self,name='DataFrameTable1', parent=None):
super(DataFrameWidget,self).__init__(parent)
self.name = name
self.dataModel = DataFrameModel()
self.dataModel.setDataFrame(DataFrame())
self.dataTable = QTableView()
#self.dataTable.setSelectionBehavior(QAbstractItemView.SelectRows)
self.dataTable.setSortingEnabled(True)
self.dataTable.setModel(self.dataModel)
self.dataModel.signalUpdate()
#self.dataTable.setFont(QFont("Courier New", 8))
layout = QVBoxLayout()
layout.addWidget(self.dataTable)
self.setLayout(layout)
def setFormat(self,fmt):
""" set non-default string formatting for a column """
for colName, f in fmt.iteritems():
self.dataModel.columnFormat[colName]=f
def fitColumns(self):
self.dataTable.horizontalHeader().setResizeMode(QHeaderView.Stretch)
def setDataFrame(self,df):
self.dataModel.setDataFrame(df)
def resizeColumnsToContents(self):
self.dataTable.resizeColumnsToContents()
def insertRow(self,index, data=None):
self.dataModel.appendRow(index,data)
class Editor(QDialog):
def __init__(self, model, parent=None):
super().__init__(parent)
self._view = QTableView()
self._view.setModel(model)
cancelButton = QPushButton(_('cancel'))
cancelButton.clicked.connect(self.reject)
okButton = QPushButton(_('OK'))
okButton.setDefault(True)
okButton.clicked.connect(self.accept)
addButton = QPushButton('+')
addButton.clicked.connect(self.add)
buttonBox = QHBoxLayout()
buttonBox.addWidget(addButton)
buttonBox.addStretch(1)
buttonBox.addWidget(cancelButton)
buttonBox.addWidget(okButton)
layout = QVBoxLayout()
layout.addWidget(self._view)
layout.addLayout(buttonBox)
self.setLayout(layout)
self.accepted.connect(self.save)
self.setWindowTitle(_('Admin.edit' + model.table))
self.resize(600, 300)
self._view.resizeColumnsToContents()
def save(self):
self._view.model().save()
def add(self):
raise NotImplementedError()
class MTestForm(QDialog):
def __init__(self, parent=None):
super(MTestForm, self).__init__(parent)
self.model = SnapshotTableModel()
self.model.addSnapshot('test.h5')
self.tablev = QTableView()
self.tablev.setModel(self.model)
self.tablev.setItemDelegate(SnapshotItemDelegate(self))
#for i in range(self.model.columnCount()):
self.tablev.resizeColumnsToContents()
self.tablev.setColumnHidden(1, True)
hb1 = QHBoxLayout()
vb2 = QVBoxLayout()
vb2.addWidget(ApPlotWidget(), 1.0)
vb3a = QVBoxLayout()
cb = QCheckBox("show PV")
self.connect(cb, SIGNAL("stateChanged(int)"), self._set_pv_view)
vb3a.addWidget(cb)
vb3a.addStretch()
vb3b = QVBoxLayout()
vb3b.addWidget(QPushButton("Refresh"))
vb3b.addWidget(QPushButton("Plot"))
vb3b.addWidget(QPushButton("Ramp"))
vb3b.addStretch()
hb2 = QHBoxLayout()
hb2.addLayout(vb3a, 1.0)
hb2.addLayout(vb3b)
vb2.addLayout(hb2)
hb1.addWidget(self.tablev, .6)
hb1.addLayout(vb2, 0.4)
self.setLayout(hb1)
def _set_pv_view(self, st):
if st == Qt.Checked: self.tablev.setColumnHidden(1, False)
elif st == Qt.Unchecked: self.tablev.setColumnHidden(1, True)
class MTestForm(QDialog):
def __init__(self, parent=None):
super(MTestForm, self).__init__(parent)
self.model = SnapshotTableModel()
self.model.addSnapshot('test.h5')
self.tablev = QTableView()
self.tablev.setModel(self.model)
self.tablev.setItemDelegate(SnapshotItemDelegate(self))
#for i in range(self.model.columnCount()):
self.tablev.resizeColumnsToContents()
self.tablev.setColumnHidden(1, True)
hb1 = QHBoxLayout()
vb2 = QVBoxLayout()
vb2.addWidget(ApPlotWidget(), 1.0)
vb3a = QVBoxLayout()
cb = QCheckBox("show PV")
self.connect(cb, SIGNAL("stateChanged(int)"), self._set_pv_view)
vb3a.addWidget(cb)
vb3a.addStretch()
vb3b = QVBoxLayout()
vb3b.addWidget(QPushButton("Refresh"))
vb3b.addWidget(QPushButton("Plot"))
vb3b.addWidget(QPushButton("Ramp"))
vb3b.addStretch()
hb2 = QHBoxLayout()
hb2.addLayout(vb3a, 1.0)
hb2.addLayout(vb3b)
vb2.addLayout(hb2)
hb1.addWidget(self.tablev, .6)
hb1.addLayout(vb2, 0.4)
self.setLayout(hb1)
def _set_pv_view(self, st):
if st == Qt.Checked: self.tablev.setColumnHidden(1, False)
elif st == Qt.Unchecked: self.tablev.setColumnHidden(1, True)
class Editor(QDialog):
def __init__(self, model, parent=None):
super().__init__(parent)
self._view = QTableView()
self._view.setModel(model)
cancelButton = QPushButton(_("cancel"))
cancelButton.clicked.connect(self.reject)
okButton = QPushButton(_("OK"))
okButton.setDefault(True)
okButton.clicked.connect(self.accept)
addButton = QPushButton("+")
addButton.clicked.connect(self.add)
buttonBox = QHBoxLayout()
buttonBox.addWidget(addButton)
buttonBox.addStretch(1)
buttonBox.addWidget(cancelButton)
buttonBox.addWidget(okButton)
layout = QVBoxLayout()
layout.addWidget(self._view)
layout.addLayout(buttonBox)
self.setLayout(layout)
self.accepted.connect(self.save)
self.setWindowTitle(_("Admin.edit" + model.table))
self.resize(600, 300)
self._view.resizeColumnsToContents()
def save(self):
self._view.model().save()
def add(self):
raise NotImplementedError()
class OrderDlg(QDialog):
def __init__(self, parent=None):
super(OrderDlg, self).__init__(parent)
self.create_widgets()
self.layout_widgets()
self.setMinimumWidth(850)
self.setWindowTitle(u'Список Order Item')
def create_widgets(self):
self.model = QtSql.QSqlRelationalTableModel(self)
self.model.setTable("CustomerOrder")
self.model.setEditStrategy(QtSql.QSqlTableModel.OnManualSubmit)
self.model.setRelation(CUSTOMER, QtSql.QSqlRelation('customerview', 'CustomerID', 'Name'))
self.model.setSort(ID, Qt.AscendingOrder)
self.model.setHeaderData(ID, Qt.Horizontal, QVariant("Order"))
self.model.setHeaderData(DATE, Qt.Horizontal, QVariant("DATE"))
self.model.setHeaderData(TIME, Qt.Horizontal, QVariant("TIME"))
self.model.setHeaderData(CUSTOMER, Qt.Horizontal,
QVariant("CUSTOMER"))
self.model.select()
self.view = QTableView()
self.view.setModel(self.model)
self.view.resizeColumnsToContents()
def layout_widgets(self):
layout = QVBoxLayout()
layout.addWidget(self.view)
self.setLayout(layout)
class OrderDlg(QDialog):
def __init__(self, parent=None):
super(OrderDlg, self).__init__(parent)
self.create_widgets()
self.layout_widgets()
self.setMinimumWidth(850)
self.setWindowTitle(u'Список Order Item')
def create_widgets(self):
self.model = QtSql.QSqlRelationalTableModel(self)
self.model.setTable("CustomerOrder")
self.model.setEditStrategy(QtSql.QSqlTableModel.OnManualSubmit)
self.model.setRelation(
CUSTOMER, QtSql.QSqlRelation('customerview', 'CustomerID', 'Name'))
self.model.setSort(ID, Qt.AscendingOrder)
self.model.setHeaderData(ID, Qt.Horizontal, QVariant("Order"))
self.model.setHeaderData(DATE, Qt.Horizontal, QVariant("DATE"))
self.model.setHeaderData(TIME, Qt.Horizontal, QVariant("TIME"))
self.model.setHeaderData(CUSTOMER, Qt.Horizontal, QVariant("CUSTOMER"))
self.model.select()
self.view = QTableView()
self.view.setModel(self.model)
self.view.resizeColumnsToContents()
def layout_widgets(self):
layout = QVBoxLayout()
layout.addWidget(self.view)
self.setLayout(layout)
def createTable(self):
# create the view
tableview = QTableView()
# set table model
tablemodel = ArrayDataTableModel(self.savedValue, self.liveValue, self)
tableview.setModel(tablemodel)
# hide vertical header
vh = tableview.verticalHeader()
vh.setVisible(False)
# set horizontal header properties
hh = tableview.horizontalHeader()
hh.setStretchLastSection(True)
# set column width to fit contents
tableview.resizeColumnsToContents()
# enable sorting
# does not work
# tableview.setSortingEnabled(True)
return tableview
class StaffDataDlg(QDialog):
def __init__(self, parent=None):
super(StaffDataDlg, self).__init__(parent)
self.create_widgets()
self.layout_widgets()
self.setMinimumWidth(850)
self.setWindowTitle(u'Список сотрудников компании')
def create_widgets(self):
self.model = QSqlTableModel(self)
self.view = QTableView()
self.view.setModel(self.model)
self.view.setSelectionMode(QTableView.SingleSelection)
self.view.setSelectionBehavior(QTableView.SelectRows)
self.view.resizeColumnsToContents()
self.buttonBox = QDialogButtonBox()
self.addButton = self.buttonBox.addButton(u"&Добавить",
QDialogButtonBox.ActionRole)
self.deleteButton = self.buttonBox.addButton(u"&Удалить",
QDialogButtonBox.ActionRole)
self.sortButton = self.buttonBox.addButton(u"&Сортировать",
QDialogButtonBox.ActionRole)
def layout_widgets(self):
layout = QVBoxLayout()
layout.addWidget(self.view)
layout.addWidget(self.buttonBox)
self.setLayout(layout)
def createTable(self):
# create the view
tableview = QTableView()
# set table model
tablemodel = ArrayDataTableModel(self.savedValue, self.liveValue, self)
tableview.setModel(tablemodel)
# hide vertical header
vh = tableview.verticalHeader()
vh.setVisible(False)
# set horizontal header properties
hh = tableview.horizontalHeader()
hh.setStretchLastSection(True)
# set column width to fit contents
tableview.resizeColumnsToContents()
# enable sorting
# does not work
# tableview.setSortingEnabled(True)
return tableview
class CSVImportDialog(QDialog):
def __init__(self, parent=None, **kwargs):
super(CSVImportDialog, self).__init__(parent, **kwargs)
self.setLayout(QVBoxLayout())
self._options = None
self._path = None
self.__update_pending = False
self._optionswidget = CSVOptionsWidget()
self._optionswidget.format_changed.connect(self._invalidate_preview)
self._stack = QStackedLayout()
self._stack.setContentsMargins(0, 0, 0, 0)
prev_box = QGroupBox("Preview")
prev_box.setLayout(self._stack)
self._preview = QTableView(tabKeyNavigation=False)
self._preview_error = QLabel()
self._stack.addWidget(self._preview)
self._stack.addWidget(self._preview_error)
buttons = QDialogButtonBox(
orientation=Qt.Horizontal,
standardButtons=(QDialogButtonBox.Ok | QDialogButtonBox.Cancel |
QDialogButtonBox.Reset)
)
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)
def on_clicked(button):
if buttons.buttonRole(button) == QDialogButtonBox.ResetRole:
self.reset()
buttons.clicked.connect(on_clicked)
self.layout().addWidget(self._optionswidget)
self.layout().addWidget(prev_box)
self.layout().addWidget(buttons)
def set_options(self, options):
self._options = options
self._optionswidget.set_dialect(options.dialect)
self._optionswidget.set_header_format(options.header_format)
self._optionswidget.set_missing_values(options.missing_values or "")
self._invalidate_preview()
def options(self):
missing_values = self._optionswidget.missing_values()
return CSV(self._optionswidget.dialect(),
header_format=self._optionswidget.header_format(),
missing_values=missing_values)
def set_path(self, path):
"""Set the preview path."""
if self._path != path:
self._path = path
self._invalidate_preview()
def path(self):
"""Return the preview path"""
return self._path
def reset(self):
"""Reset the options to their default values."""
self.set_options(self._options)
def _invalidate_preview(self):
if not self.__update_pending:
self.__update_pending = True
QApplication.postEvent(self, QEvent(QEvent.User))
def customEvent(self, event):
if self.__update_pending:
self.__update_pending = False
self._update_preview()
def _update_preview(self):
if not self._path:
return
head = itertools.islice(open(self._path, "rU"), 20)
head = StringIO("".join(head))
try:
data = load_csv(head, **self.options()._asdict())
except csv.Error as err:
self._preview_error.setText(
"Cannot load data preview:\n {!s}".format(err)
)
self._stack.setCurrentWidget(self._preview_error)
except (Orange.data.io.CSVFormatError,
Orange.data.io.VariableDefinitionError) as err:
self._preview_error.setText(
"Data formating error:\n {!s}".format(err)
)
self._stack.setCurrentWidget(self._preview_error)
except Exception as err:
self._preview_error.setText(
"Cannot load data preview:\n {!s}".format(err)
)
self._stack.setCurrentWidget(self._preview_error)
raise
else:
model = TableModel(data, None, self)
self._preview.setModel(model)
self._preview.resizeColumnsToContents()
self._stack.setCurrentWidget(self._preview)
class CSVImportDialog(QDialog):
def __init__(self, parent=None, **kwargs):
super(CSVImportDialog, self).__init__(parent, **kwargs)
self.setLayout(QVBoxLayout())
self._options = None
self._path = None
self.__update_pending = False
self._optionswidget = CSVOptionsWidget()
self._optionswidget.format_changed.connect(self._invalidate_preview)
self._stack = QStackedLayout()
self._stack.setContentsMargins(0, 0, 0, 0)
prev_box = QGroupBox("Preview")
prev_box.setLayout(self._stack)
self._preview = QTableView(tabKeyNavigation=False)
self._preview_error = QLabel()
self._stack.addWidget(self._preview)
self._stack.addWidget(self._preview_error)
buttons = QDialogButtonBox(
orientation=Qt.Horizontal,
standardButtons=(QDialogButtonBox.Ok | QDialogButtonBox.Cancel
| QDialogButtonBox.Reset))
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)
def on_clicked(button):
if buttons.buttonRole(button) == QDialogButtonBox.ResetRole:
self.reset()
buttons.clicked.connect(on_clicked)
self.layout().addWidget(self._optionswidget)
self.layout().addWidget(prev_box)
self.layout().addWidget(buttons)
def set_options(self, options):
self._options = options
self._optionswidget.set_dialect(options.dialect)
self._optionswidget.set_header_format(options.header_format)
self._optionswidget.set_missing_values(options.missing_values or "")
self._invalidate_preview()
def options(self):
missing_values = self._optionswidget.missing_values()
return CSV(self._optionswidget.dialect(),
header_format=self._optionswidget.header_format(),
missing_values=missing_values)
def set_path(self, path):
"""Set the preview path."""
if self._path != path:
self._path = path
self._invalidate_preview()
def path(self):
"""Return the preview path"""
return self._path
def reset(self):
"""Reset the options to their default values."""
self.set_options(self._options)
def _invalidate_preview(self):
if not self.__update_pending:
self.__update_pending = True
QApplication.postEvent(self, QEvent(QEvent.User))
def customEvent(self, event):
if self.__update_pending:
self.__update_pending = False
self._update_preview()
def _update_preview(self):
if not self._path:
return
head = itertools.islice(open(self._path, "rU"), 20)
head = StringIO("".join(head))
try:
data = load_csv(head, **self.options()._asdict())
except csv.Error as err:
self._preview_error.setText(
"Cannot load data preview:\n {!s}".format(err))
self._stack.setCurrentWidget(self._preview_error)
except (Orange.data.io.CSVFormatError,
Orange.data.io.VariableDefinitionError) as err:
self._preview_error.setText(
"Data formating error:\n {!s}".format(err))
self._stack.setCurrentWidget(self._preview_error)
except Exception as err:
self._preview_error.setText(
"Cannot load data preview:\n {!s}".format(err))
self._stack.setCurrentWidget(self._preview_error)
raise
else:
model = TableModel(data, None, self)
self._preview.setModel(model)
self._preview.resizeColumnsToContents()
self._stack.setCurrentWidget(self._preview)
class ReferenceDataDlg(QDialog):
def __init__(self, table, title, parent=None):
super(ReferenceDataDlg, self).__init__(parent)
self.create_widgets(table)
self.layout_widgets()
self.create_connections()
self.setWindowTitle(
"Asset Manager - Edit {0} Reference Data".format(title))
def create_widgets(self, table):
self.model = QSqlTableModel(self)
self.model.setTable(table)
self.model.setSort(NAME, Qt.AscendingOrder)
self.model.setHeaderData(ID, Qt.Horizontal, QVariant("ID"))
self.model.setHeaderData(NAME, Qt.Horizontal, QVariant("Name"))
self.model.setHeaderData(DESCRIPTION, Qt.Horizontal,
QVariant("Description"))
self.model.select()
self.view = QTableView()
self.view.setModel(self.model)
self.view.setSelectionMode(QTableView.SingleSelection)
self.view.setSelectionBehavior(QTableView.SelectRows)
self.view.setColumnHidden(ID, True)
self.view.resizeColumnsToContents()
self.addButton = QPushButton("&Add")
self.deleteButton = QPushButton("&Delete")
self.okButton = QPushButton("&OK")
def layout_widgets(self):
buttonLayout = QHBoxLayout()
buttonLayout.addWidget(self.addButton)
buttonLayout.addWidget(self.deleteButton)
buttonLayout.addStretch()
buttonLayout.addWidget(self.okButton)
layout = QVBoxLayout()
layout.addWidget(self.view)
layout.addLayout(buttonLayout)
self.setLayout(layout)
def create_connections(self):
self.addButton.clicked.connect(self.addRecord)
self.deleteButton.clicked.connect(self.deleteRecord)
self.okButton.clicked.connect(self.accept)
def addRecord(self):
row = self.model.rowCount()
self.model.insertRow(row)
index = self.model.index(row, NAME)
self.view.setCurrentIndex(index)
self.view.edit(index)
def deleteRecord(self):
index = self.view.currentIndex()
if not index.isValid():
return
record = self.model.record(index.row())
id = record.value(ID).toInt()[0]
table = self.model.tableName()
query = QSqlQuery()
if table == "deps":
query.exec_(QString("SELECT COUNT(*) FROM employee "
"WHERE deo_id = %1").arg(id))
elif table == "cities":
query.exec_(QString("SELECT COUNT(*) FROM employee "
"WHERE city_id = %1").arg(id))
count = 0
if query.next():
count = query.value(0).toInt()[0]
if count:
QMessageBox.information(self,
QString("Delete %1").arg(table),
(QString("Cannot delete %1<br>"
"from the %2 table because it is used by "
"%3 records")
.arg(record.value(NAME).toString())
.arg(table).arg(count)))
return
self.model.removeRow(index.row())
self.model.submitAll()
class StaffDataDlg(QDialog):
def __init__(self, parent=None):
super(StaffDataDlg, self).__init__(parent)
self.create_widgets()
self.layout_widgets()
self.create_connections()
self.setMinimumWidth(850)
self.setWindowTitle(u'Список сотрудников компании')
def create_widgets(self):
self.model = QtSql.QSqlRelationalTableModel(self)
self.model.setTable("employee")
self.model.setEditStrategy(QtSql.QSqlTableModel.OnManualSubmit)
self.model.setRelation(CITY, QtSql.QSqlRelation('cities', 'city_id', 'name'))
self.model.setRelation(DEPARTMENT, QtSql.QSqlRelation('deps', 'dep_id', 'name'))
self.model.setSort(ID, Qt.AscendingOrder)
self.model.setHeaderData(ID, Qt.Horizontal, QVariant("ID"))
self.model.setHeaderData(CITY, Qt.Horizontal,
QVariant("City"))
self.model.setHeaderData(DEPARTMENT, Qt.Horizontal,
QVariant("Department"))
self.model.setHeaderData(FIRSTNAME, Qt.Horizontal,
QVariant("First Name"))
self.model.setHeaderData(LASTNAME, Qt.Horizontal,
QVariant("Last Name"))
self.model.setHeaderData(SEX, Qt.Horizontal,
QVariant("sex"))
self.model.setHeaderData(ADDRESS, Qt.Horizontal,
QVariant("Address"))
self.model.setHeaderData(PID, Qt.Horizontal,
QVariant("PID"))
self.model.setHeaderData(TITLE, Qt.Horizontal,
QVariant("Title"))
self.model.setHeaderData(SOLARY, Qt.Horizontal,
QVariant("SOLARY"))
self.model.setHeaderData(SHIFT, Qt.Horizontal,
QVariant("SHIFT"))
self.model.setHeaderData(HOURS, Qt.Horizontal,
QVariant("HOURS"))
self.model.select()
self.view = QTableView()
self.view.setModel(self.model)
self.view.setItemDelegate(QtSql.QSqlRelationalDelegate(self))
self.view.setColumnHidden(ID, True)
self.view.resizeColumnsToContents()
self.buttonBox = QDialogButtonBox()
self.addCity = self.buttonBox.addButton(u"&Добавить City",
QDialogButtonBox.ActionRole)
self.addDep = self.buttonBox.addButton(u"&Добавить Department",
QDialogButtonBox.ActionRole)
self.addButton = self.buttonBox.addButton(u"&Добавить",
QDialogButtonBox.ActionRole)
self.deleteButton = self.buttonBox.addButton(u"&Удалить",
QDialogButtonBox.ActionRole)
self.sortButton = self.buttonBox.addButton(u"&Сортировать",
QDialogButtonBox.ActionRole)
menu = QMenu(self)
self.sortByTitleAction = menu.addAction(u"Сортировка по &Title")
self.sortBySolaryAction = menu.addAction(
u"Сортировка по &SOLARY")
self.sortByIDAction = menu.addAction(u"Сортировка по &ID")
self.sortButton.setMenu(menu)
self.closeButton = self.buttonBox.addButton(QDialogButtonBox.Close)
def layout_widgets(self):
layout = QVBoxLayout()
layout.addWidget(self.view)
layout.addWidget(self.buttonBox)
self.setLayout(layout)
def create_connections(self):
self.addButton.clicked.connect(self.addRecord)
self.deleteButton.clicked.connect(self.deleteRecord)
self.addCity.clicked.connect(self.editCities)
self.sortByTitleAction.triggered.connect(
lambda: self.sort(TITLE))
self.sortBySolaryAction.triggered.connect(
lambda: self.sort(SOLARY))
self.sortByIDAction.triggered.connect(lambda: self.sort(ID))
self.closeButton.clicked.connect(self.accept)
def addRecord(self):
row = self.model.rowCount()
self.model.insertRow(row)
index = self.model.index(row, TITLE)
self.view.setCurrentIndex(index)
self.view.edit(index)
def deleteRecord(self):
index = self.view.currentIndex()
if not index.isValid():
return
record = self.model.record(index.row())
title = record.value(TITLE).toString()
desc = record.value(SOLARY).toString()
if (QMessageBox.question(self, "Reference Data",
QString("Delete %1 from title %2?")
.arg(desc).arg(title),
QMessageBox.Yes|QMessageBox.No) ==
QMessageBox.No):
return
self.model.removeRow(index.row())
self.model.submitAll()
def sort(self, column):
self.model.setSort(column, Qt.AscendingOrder)
self.model.select()
def editCities(self):
form = ReferenceDataDlg("cities", "Cities", self)
form.exec_()
class QueueDialog(Window):
def __init__(self, base):
Window.__init__(self, base, i18n.get('messages_queue'))
self.setFixedSize(500, 400)
self.last_timestamp = None
self.showed = False
self.list_ = QTableView()
self.list_.setSelectionBehavior(QAbstractItemView.SelectRows)
self.list_.clicked.connect(self.__account_clicked)
self.caption = QLabel()
self.caption.setWordWrap(True)
self.caption.setAlignment(Qt.AlignCenter)
self.estimated_time = QLabel()
self.estimated_time.setWordWrap(True)
self.estimated_time.setAlignment(Qt.AlignCenter)
self.delete_button = QPushButton(i18n.get('delete'))
self.delete_button.setEnabled(False)
self.delete_button.setToolTip(i18n.get('delete_selected_message'))
self.delete_button.clicked.connect(self.__delete_message)
self.clear_button = QPushButton(i18n.get('delete_all'))
self.clear_button.setEnabled(False)
self.clear_button.setToolTip(i18n.get('delete_all_messages_in_queue'))
self.clear_button.clicked.connect(self.__delete_all)
button_box = QHBoxLayout()
button_box.addStretch(1)
button_box.addWidget(self.clear_button)
button_box.addWidget(self.delete_button)
layout = QVBoxLayout()
layout.addWidget(self.list_, 1)
layout.addWidget(self.caption)
layout.addWidget(self.estimated_time)
layout.addLayout(button_box)
layout.setSpacing(5)
layout.setContentsMargins(5, 5, 5, 5)
self.setLayout(layout)
def __account_clicked(self, point):
self.delete_button.setEnabled(True)
self.clear_button.setEnabled(True)
def __delete_message(self):
self.__disable()
selection = self.list_.selectionModel()
index = selection.selectedIndexes()[0]
message = i18n.get('delete_message_from_queue_confirm')
confirmation = self.base.show_confirmation_message(
i18n.get('confirm_delete'), message)
if not confirmation:
self.__enable()
return
self.base.delete_message_from_queue(index.row())
def __delete_all(self):
self.__disable()
message = i18n.get('clear_message_queue_confirm')
confirmation = self.base.show_confirmation_message(
i18n.get('confirm_delete'), message)
if not confirmation:
self.__enable()
return
self.base.clear_queue()
def __enable(self):
self.list_.setEnabled(True)
self.delete_button.setEnabled(False)
if len(self.base.core.list_statuses_queue()) > 0:
self.clear_button.setEnabled(True)
else:
self.clear_button.setEnabled(False)
def __disable(self):
self.list_.setEnabled(False)
self.delete_button.setEnabled(False)
self.clear_button.setEnabled(False)
def __on_timeout(self):
now = int(time.time())
interval = self.base.core.get_queue_interval() * 60
if self.last_timestamp:
est_time = ((self.last_timestamp + interval) - now) / 60
else:
est_time = 0
humanized_est_time = self.base.humanize_time_intervals(est_time)
next_message = ' '.join(
[i18n.get('next_message_should_be_posted_in'), humanized_est_time])
if len(self.base.core.list_statuses_queue()) == 0:
self.estimated_time.setText('')
else:
self.estimated_time.setText(next_message)
def start(self):
self.timer = QTimer()
self.timer.timeout.connect(self.__on_timeout)
self.timer.start(60000)
def closeEvent(self, event=None):
if event:
event.ignore()
self.hide()
self.showed = False
def show(self):
if self.showed:
self.raise_()
return
self.update()
Window.show(self)
self.showed = True
def update(self):
model = QStandardItemModel()
model.setHorizontalHeaderItem(0, QStandardItem(i18n.get('account')))
model.setHorizontalHeaderItem(1, QStandardItem(i18n.get('message')))
self.list_.setModel(model)
now = int(time.time())
interval = self.base.core.get_queue_interval() * 60
if self.last_timestamp:
est_time = ((self.last_timestamp + interval) - now) / 60
else:
est_time = 0
row = 0
for status in self.base.core.list_statuses_queue():
username = get_username_from(status.account_id)
protocol_image = "%s.png" % get_protocol_from(status.account_id)
item = QStandardItem(QString.fromUtf8(username))
item.setIcon(QIcon(self.base.load_image(protocol_image, True)))
model.setItem(row, 0, item)
model.setItem(row, 1, QStandardItem(QString.fromUtf8(status.text)))
row += 1
humanized_interval = self.base.humanize_time_intervals(
self.base.core.get_queue_interval())
humanized_est_time = self.base.humanize_time_intervals(est_time)
warning = i18n.get('messages_will_be_send') % humanized_interval
next_message = ' '.join(
[i18n.get('next_message_should_be_posted_in'), humanized_est_time])
self.caption.setText(warning)
if row == 0:
self.estimated_time.setText('')
else:
self.estimated_time.setText(next_message)
self.list_.horizontalHeader().setResizeMode(1, QHeaderView.Stretch)
self.list_.resizeColumnsToContents()
self.__enable()
def update_timestamp(self):
if len(self.base.core.list_statuses_queue()) > 0:
self.last_timestamp = int(time.time())
else:
self.last_timestamp = None
class ComponentSearchForm():
data_source = None
related_mashups = None
widget = None
table = None
add_btn = None
graph_form = None
highlighted_api = None
highlighted_mashup = None
def show_main_window(self):
self.graph_form = matplotlibWidget()
if self.widget:
self.widget.destroy()
self.widget = None;
self.widget = QWidget()
self.widget.setMinimumSize(800, 600)
btn_api = QtGui.QPushButton("Recommend Modules", self.widget)
btn_api.move(30, 20)
btn_mashup = QtGui.QPushButton("Recommend Workflows", self.widget)
btn_mashup.move(200, 20)
self.textboxLabel = QLabel(self.widget)
self.textboxLabel.setText("Describe your goals:")
self.textboxLabel.move(35, 60)
self.textboxLabel.show
self.textbox = QTextEdit(self.widget)
self.textbox.move(30, 80)
self.textbox.setFixedWidth(300)
self.textbox.setFixedHeight(28)
btn_api.clicked.connect(self.api_button_clicked)
btn_mashup.clicked.connect(self.mashups_button_clicked)
self.table = QTableView(self.widget)
self.table.clicked.connect(self.table_clicked)
self.table.setMinimumSize(740, 500)
self.table.resizeColumnsToContents()
self.table.move(30, 120)
self.widget.show()
self.add_btn = QPushButton(self.widget)
self.add_btn.clicked.connect(self.add_new_api)
self.add_btn.setText("Add to Palette")
self.add_btn.hide()
self.add_btn.move(650, 20)
self.recommendLabel = QLabel(self.widget)
self.recommendLabel.setText("Also Used")
self.recommendLabel.move(30, 95)
self.recommendLabel.hide()
self.switch_btn_apis = QPushButton(self.widget)
self.switch_btn_apis.clicked.connect(self._show_related_apis)
self.switch_btn_apis.setText("Related Mashup")
self.switch_btn_apis.move(500, 20)
self.switch_btn_apis.hide()
self.switch_btn_mashups = QPushButton(self.widget)
self.switch_btn_mashups.clicked.connect(self._show_related_mashups)
self.switch_btn_mashups.setText("Related API")
self.switch_btn_mashups.move(500, 20)
self.switch_btn_mashups.hide()
def __init__(self, parent=None):
self.data_source = DataSource()
def table_clicked(self):
"""
Click the table, the graph form may change according to the selection.
"""
model = self.table.selectionModel()
indexes = model.selectedIndexes()
for index in indexes:
row = index.row()
data = index.model().headerData(0,Qt.Horizontal).toString()
newIndex = index.model().index(row, 0)
if data == "API":
api_id = get_api_full_name(newIndex.model().data(newIndex).toString())
api = self.data_source.api_by_id(api_id)
print api
mashups = self.data_source.mashups_by_api(api)
apis = []
for mashup in mashups:
apis.extend(self.data_source.apis_by_mashup(mashup))
self.graph_form.draw_apis(apis, api, self.highlighted_api)
else:
mashup_id = get_mashup_full_name(newIndex.model().data(newIndex).toString())
mashup = self.data_source.mashup_by_id(mashup_id)
if not mashup:
return
apis = self.data_source.apis_by_mashup(mashup)
mashups = []
if len(apis) > 0:
mashups.extend(self.data_source.mashups_by_api(apis[0]))
self.graph_form.draw_mashups(mashups, mashup, self.highlighted_mashup)
return
def _show_apis(self, apis, recommend=False):
self.switch_btn_apis.hide()
self.switch_btn_mashups.hide()
self.recommendLabel.hide()
row = 0
model = QStandardItemModel(len(apis), 4)
model.setColumnCount(4)
for api in apis:
model.setData(model.index(row, 0), QVariant(get_api_name(api)))
model.setData(model.index(row, 1), QVariant(api['protocols']))
model.setData(model.index(row, 2), QVariant(api['provider']))
model.setData(model.index(row, 3), QVariant(api['version']))
row += 1
model.setHeaderData(0, Qt.Horizontal, QVariant("Module"))
model.setHeaderData(1, Qt.Horizontal, QVariant("Protocol"))
model.setHeaderData(2, Qt.Horizontal, QVariant("Provider"))
model.setHeaderData(3, Qt.Horizontal, QVariant("Version"))
# model.setHeaderData(0, Qt.Horizontal, QVariant("API"))
# model.setHeaderData(1, Qt.Horizontal, QVariant("Protocols"))
# model.setHeaderData(2, Qt.Horizontal, QVariant("Provider"))
# model.setHeaderData(3, Qt.Horizontal, QVariant("Version"))
self.table.setModel(model)
self.table.resizeColumnsToContents()
if recommend:
self.recommendLabel.show()
self.add_btn.show()
def _show_mashups(self, mashups):
self.switch_btn_apis.hide()
self.switch_btn_mashups.hide()
self.recommendLabel.hide()
row = 0
model = QStandardItemModel(len(mashups), 4)
model.setColumnCount(4)
for mashup in mashups:
model.setData(model.index(row, 0), QVariant(get_mashup_name(mashup)))
model.setData(model.index(row, 1), QVariant(mashup['title']))
model.setData(model.index(row, 2), QVariant(mashup['self']))
model.setData(model.index(row, 3), QVariant(mashup['description']))
row += 1
model.setHeaderData(0, Qt.Horizontal, QVariant("Workflow"))
model.setHeaderData(1, Qt.Horizontal, QVariant("Short Description"))
model.setHeaderData(2, Qt.Horizontal, QVariant("Provider"))
model.setHeaderData(3, Qt.Horizontal, QVariant("Detailed Info"))
# model.setHeaderData(0, Qt.Horizontal, QVariant("Info"))
# model.setHeaderData(1, Qt.Horizontal, QVariant("Title"))
# model.setHeaderData(2, Qt.Horizontal, QVariant("self"))
# model.setHeaderData(3, Qt.Horizontal, QVariant("Description"))
self.table.setModel(model)
self.table.resizeColumnsToContents()
self.add_btn.show()
def api_button_clicked(self):
"""
Trigger to search APIs
"""
self.graph_form.draw_api()
self.graph_form.show()
apis = self.data_source.apis()
key = str(self.textbox.toPlainText())
#Has key or not has key, it is different.
if key:
self.api_search_button_clicked()
else:
self._show_apis(apis)
def mashups_button_clicked(self):
"""
Trigger to search mashups
"""
self.graph_form.draw_mashup()
self.graph_form.show()
key = str(self.textbox.toPlainText())
if key:
self.mashup_search_button_clicked()
else:
self._show_mashups(self.data_source.mashups())
#Should probably refactor this into one method.
def api_search_button_clicked(self):
"""
Search when no keyword
"""
self.highlighted_api = None
self.highlighted_mashup = None
key = str(self.textbox.toPlainText())
if key != "":
apis = self.data_source.search_api(key)
self._show_apis(apis)
def mashup_search_button_clicked(self):
"""
Search when no keyword
"""
self.highlighted_api = None
self.highlighted_mashup = None
key = str(self.textbox.toPlainText())
if key != "":
mashups = self.data_source.search_mashup(key)
self._show_mashups(mashups)
def add_new_api(self):
"""
Add new api to the modules package.
"""
apis = self.data_source.apis()
model = self.table.selectionModel()
indexes = model.selectedIndexes()
for index in indexes:
api = apis[index.row()]
self._add_new_api(api)
return
def add_related_api(self):
objs = []
for mashup in self.related_mashups:
objs.append(mashup)
for api in mashup["related_mashups"]:
objs.append(api)
model = self.table.selectionModel()
indexes = model.selectedIndexes()
for index in indexes:
api = objs[index.row()]
if api.get("protocols"):
self._add_new_api(api)
return
def _show_related_mashups(self):
self.switch_btn_apis.hide()
self.switch_btn_mashups.hide()
self.recommendLabel.hide()
apis = []
objs = []
for mashup in self.related_mashups:
apis.extend(mashup["related_mashups"])
for api in apis:
objs.append(api)
mashups = self.data_source.mashups_by_api(api)
objs.extend(mashups)
row = 0
model = QStandardItemModel(len(objs), 4)
model.setColumnCount(4)
for obj in objs:
if obj.get('protocols'):
model.setData(model.index(row, 0), QVariant(get_api_name(obj)))
model.setData(model.index(row, 1), QVariant(obj['protocols']))
model.setData(model.index(row, 2), QVariant(obj['provider']))
else:
model.setData(model.index(row, 3), QVariant(get_mashup_name(obj)))
row += 1
model.setHeaderData(0, Qt.Horizontal, QVariant("API"))
model.setHeaderData(1, Qt.Horizontal, QVariant("Protocols"))
model.setHeaderData(2, Qt.Horizontal, QVariant("Provider"))
model.setHeaderData(3, Qt.Horizontal, QVariant("Mashup"))
self.table.setModel(model)
self.table.resizeColumnsToContents()
self.switch_btn_apis.show()
def _show_related_apis(self):
self.switch_btn_apis.hide()
self.switch_btn_mashups.hide()
self.recommendLabel.hide()
row = 0
objs = []
for mashup in self.related_mashups:
objs.append(mashup)
for api in mashup["related_mashups"]:
objs.append(api)
#Combining similarity and related.
similar_apis = self.data_source.search_api_similarity(self.highlighted_api)
#return str(mashup['id'])[(len("http://www.programmableweb.com/mashup/")):]
objs.append({'id': "http://www.programmableweb.com/mashup/Using-Similarity-Metric"})
objs.extend(similar_apis)
#Combining similarity and related.
model = QStandardItemModel(len(objs), 5)
for obj in objs:
if obj.get('protocols'):
model.setData(model.index(row, 1), QVariant(get_api_name(obj)))
model.setData(model.index(row, 2), QVariant(obj['protocols']))
model.setData(model.index(row, 3), QVariant(obj['provider']))
model.setData(model.index(row, 4), QVariant(obj['version']))
else:
model.setData(model.index(row, 0), QVariant(get_mashup_name(obj)))
row += 1
model.setHeaderData(0, Qt.Horizontal, QVariant("Mashup"))
model.setHeaderData(1, Qt.Horizontal, QVariant("API"))
model.setHeaderData(2, Qt.Horizontal, QVariant("Protocols"))
model.setHeaderData(3, Qt.Horizontal, QVariant("Provider"))
model.setHeaderData(4, Qt.Horizontal, QVariant("Version"))
self.table.setModel(model)
self.switch_btn_mashups.show()
def _add_new_api(self, api):
self.highlighted_api = api
mashups = self.data_source.mashups_by_api(api)
for mashup in mashups:
mashup['related_mashups'] = (self.data_source.apis_by_mashup(mashup))
if len(mashups) > 0:
self.related_mashups = mashups
self._show_related_apis()
manager = core.packagemanager.get_package_manager()
reg = core.modules.module_registry.get_module_registry()
package = manager.get_package("edu.cmu.sv.components", "1.0.0")
core.modules.module_registry.set_current_package(package)
if (api["protocols"] == "SOAP" and api["wsdl"] != ""):
s = Service(api["wsdl"])
add_new_service(s, api["wsdl"])
else:
new_module = vistrails_module.new_module(Module, get_api_name(api))
reg.add_module(new_module)
reg.add_input_port(new_module, "value1",
(core.modules.basic_modules.String, 'the first argument'))
reg.add_input_port(new_module, "value2",
(core.modules.basic_modules.String, 'the second argument'))
reg.add_output_port(new_module, "value",
(core.modules.basic_modules.String, 'the result'))
class FreezeTableWidget(QTableView):
def __init__(
self, table_data, headers, parent = None, *args
):
"""
Creates two QTableViews one of which is a frozen table while the
other one can scroll behind it.
:param table_data: The data that goes into the tables
:type table_data: List
:param headers: The header data of the tables.
:type headers: List
:param parent: The parent of the QTableView
:type parent: QWidget
:param args:
:type args:
"""
QTableView.__init__(self, parent)
# set the table model
self.table_model = BaseSTDMTableModel(
table_data, headers, parent
)
# set the proxy model
proxy_model = QSortFilterProxyModel(self)
proxy_model.setSourceModel(self.table_model)
# Assign a data model for TableView
self.setModel(self.table_model)
# frozen_table_view - first column
self.frozen_table_view = QTableView(self)
# Set the model for the widget, fixed column
self.frozen_table_view.setModel(self.table_model)
# Hide row headers
self.frozen_table_view.verticalHeader().hide()
# Widget does not accept focus
self.frozen_table_view.setFocusPolicy(
Qt.StrongFocus|Qt.TabFocus|Qt.ClickFocus
)
# The user can not resize columns
self.frozen_table_view.horizontalHeader().\
setResizeMode(QHeaderView.Fixed)
self.frozen_table_view.setObjectName('frozen_table')
self.setSelectionMode(QAbstractItemView.NoSelection)
# Remove the scroll bar
self.frozen_table_view.setHorizontalScrollBarPolicy(
Qt.ScrollBarAlwaysOff
)
self.frozen_table_view.setVerticalScrollBarPolicy(
Qt.ScrollBarAlwaysOff
)
# Puts more widgets to the foreground
self.viewport().stackUnder(self.frozen_table_view)
# # Log in to edit mode - even with one click
# Set the properties of the column headings
hh = self.horizontalHeader()
# Text alignment centered
hh.setDefaultAlignment(Qt.AlignCenter)
self.set_column_width()
# Set properties header lines
vh = self.verticalHeader()
vh.setDefaultSectionSize(25) # height lines
# text alignment centered
vh.setDefaultAlignment(Qt.AlignCenter)
vh.setVisible(True)
# Height of rows - as in the main widget
self.frozen_table_view.verticalHeader().\
setDefaultSectionSize(
vh.defaultSectionSize()
)
# Show frozen table view
self.frozen_table_view.show()
# Set the size of him like the main
self.setHorizontalScrollMode(
QAbstractItemView.ScrollPerPixel
)
self.setVerticalScrollMode(
QAbstractItemView.ScrollPerPixel
)
self.frozen_table_view.setVerticalScrollMode(
QAbstractItemView.ScrollPerPixel
)
## select the first column (STR Type)
self.frozen_table_view.selectColumn(0)
self.frozen_table_view.setEditTriggers(
QAbstractItemView.AllEditTriggers
)
self.set_size()
self.signals()
def set_size(self):
"""
Sets the size and size policy of the tables.
:return:
:rtype:
"""
size_policy = QSizePolicy(
QSizePolicy.Fixed, QSizePolicy.Fixed
)
size_policy.setHorizontalStretch(0)
size_policy.setVerticalStretch(0)
size_policy.setHeightForWidth(
self.sizePolicy().hasHeightForWidth()
)
self.setSizePolicy(size_policy)
self.setMinimumSize(QSize(55, 75))
self.setMaximumSize(QSize(5550, 5555))
self.SelectionMode(
QAbstractItemView.SelectColumns
)
# set column width to fit contents
self.frozen_table_view.resizeColumnsToContents()
# set row height
self.frozen_table_view.resizeRowsToContents()
def signals(self):
"""
Connects signals of the tables.
"""
# Connect the headers and scrollbars of
# both tableviews together
self.horizontalHeader().sectionResized.connect(
self.update_section_width
)
self.verticalHeader().sectionResized.connect(
self.update_section_height
)
self.frozen_table_view.verticalScrollBar().valueChanged.connect(
self.verticalScrollBar().setValue
)
self.verticalScrollBar().valueChanged.connect(
self.frozen_table_view.verticalScrollBar().setValue
)
def set_column_width(self):
"""
Sets the column width of the frozen QTableView.
"""
# Set the width of columns
columns_count = self.table_model.columnCount(self)
for col in range(columns_count):
if col == 0:
# Set the size
self.horizontalHeader().resizeSection(
col, 60
)
# Fix width
self.horizontalHeader().setResizeMode(
col, QHeaderView.Fixed
)
# Width of a fixed column - as in the main widget
self.frozen_table_view.setColumnWidth(
col, self.columnWidth(col)
)
elif col == 1:
self.horizontalHeader().resizeSection(
col, 150
)
self.horizontalHeader().setResizeMode(
col, QHeaderView.Fixed
)
self.frozen_table_view.setColumnWidth(
col, self.columnWidth(col)
)
else:
self.horizontalHeader().resizeSection(
col, 150
)
# Hide unnecessary columns in the
# widget fixed columns
self.frozen_table_view.setColumnHidden(
col, True
)
def add_widgets(self, spatial_unit, insert_row):
"""
Adds widget into the frozen table.
:param str_type_id: The STR type id of the tenure type combobox
:type str_type_id: Integer
:param insert_row: The row number the widgets to be added.
:type insert_row: Integer
"""
delegate = STRTypeDelegate(spatial_unit)
# Set delegate to add combobox under
# social tenure type column
self.frozen_table_view.setItemDelegate(
delegate
)
self.frozen_table_view.setItemDelegateForColumn(
0, delegate
)
index = self.frozen_table_view.model().index(
insert_row, 0, QModelIndex()
)
self.frozen_table_view.model().setData(
index, '', Qt.EditRole
)
self.frozen_table_view.openPersistentEditor(
self.frozen_table_view.model().index(insert_row, 0)
)
self.frozen_table_view.openPersistentEditor(
self.frozen_table_view.model().index(insert_row, 1)
)
def update_section_width(
self, logicalIndex, oldSize, newSize
):
"""
Updates frozen table column width and geometry.
:param logicalIndex: The section's logical number
:type logicalIndex: Integer
:param oldSize: The old size of the section
:type oldSize: Integer
:param newSize: The new size of the section
:type newSize: Integer
"""
if logicalIndex==0 or logicalIndex==1:
self.frozen_table_view.setColumnWidth(
logicalIndex, newSize
)
self.update_frozen_table_geometry()
def update_section_height(
self, logicalIndex, oldSize, newSize
):
"""
Updates frozen table column height.
:param logicalIndex: The section's logical number
:type logicalIndex: Integer
:param oldSize: The old size of the section
:type oldSize: Integer
:param newSize: The new size of the section
:type newSize: Integer
"""
self.frozen_table_view.setRowHeight(
logicalIndex, newSize
)
def resizeEvent(self, event):
"""
Handles the resize event of the frozen table view.
It updates the frozen table view geometry on resize of table.
:param event: The event
:type event: QEvent
"""
QTableView.resizeEvent(self, event)
try:
self.update_frozen_table_geometry()
except Exception as log:
LOGGER.debug(str(log))
def scrollTo(self, index, hint):
"""
Scrolls the view if necessary to ensure that the item at index is
visible. The view will try to position the item according to the
given hint.
:param index: The scroll index
:type index: QModelIndex
:param hint: The scroll hint
:type hint: Integer
"""
if index.column() > 1:
QTableView.scrollTo(self, index, hint)
def update_frozen_table_geometry(self):
"""
Updates the frozen table view geometry.
"""
if self.verticalHeader().isVisible():
self.frozen_table_view.setGeometry(
self.verticalHeader().width() +
self.frameWidth(),
self.frameWidth(),
self.columnWidth(0) + self.columnWidth(1),
self.viewport().height() +
self.horizontalHeader().height()
)
else:
self.frozen_table_view.setGeometry(
self.frameWidth(),
self.frameWidth(),
self.columnWidth(0) + self.columnWidth(1),
self.viewport().height() +
self.horizontalHeader().height()
)
def move_cursor(self, cursor_action, modifiers):
"""
Override function for correct left to scroll the keyboard.
Returns a QModelIndex object pointing to the next object in the
table view, based on the given cursorAction and keyboard modifiers
specified by modifiers.
:param cursor_action: The cursor action
:type cursor_action: Integer
:param modifiers: Qt.KeyboardModifier value.
:type modifiers: Object
:return: The current cursor position.
:rtype: QModelIndex
"""
current = QTableView.move_cursor(
self, cursor_action, modifiers
)
if cursor_action == self.MoveLeft and current.column() > 1 and \
self.visualRect(current).topLeft().x() < \
(self.frozen_table_view.columnWidth(0) +
self.frozen_table_view.columnWidth(1)):
new_value = self.horizontalScrollBar().value() + \
self.visualRect(current).topLeft().x() - \
(self.frozen_table_view.columnWidth(0) +
self.frozen_table_view.columnWidth(1))
self.horizontalScrollBar().setValue(new_value)
return current
def main(icon_spec):
app = QApplication(sys.argv)
main_window = QMainWindow()
def sigint_handler(*args):
main_window.close()
signal.signal(signal.SIGINT, sigint_handler)
# the timer enables triggering the sigint_handler
signal_timer = QTimer()
signal_timer.start(100)
signal_timer.timeout.connect(lambda: None)
tool_bar = QToolBar()
main_window.addToolBar(Qt.TopToolBarArea, tool_bar)
table_view = QTableView()
table_view.setSelectionBehavior(QAbstractItemView.SelectRows)
table_view.setSelectionMode(QAbstractItemView.SingleSelection)
table_view.setSortingEnabled(True)
main_window.setCentralWidget(table_view)
proxy_model = QSortFilterProxyModel()
proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive)
proxy_model.setFilterKeyColumn(1)
table_view.setModel(proxy_model)
proxy_model.layoutChanged.connect(table_view.resizeRowsToContents)
item_model = QStandardItemModel()
proxy_model.setSourceModel(item_model)
# get all icons and their available sizes
QIcon.setThemeName("gnome")
icons = []
all_sizes = set([])
for context, icon_names in icon_spec:
for icon_name in icon_names:
icon = QIcon.fromTheme(icon_name)
sizes = []
for size in icon.availableSizes():
size = (size.width(), size.height())
sizes.append(size)
all_sizes.add(size)
sizes.sort()
icons.append({
'context': context,
'icon_name': icon_name,
'icon': icon,
'sizes': sizes,
})
all_sizes = list(all_sizes)
all_sizes.sort()
# input field for filter
def filter_changed(value):
proxy_model.setFilterRegExp(value)
table_view.resizeRowsToContents()
filter_line_edit = QLineEdit()
filter_line_edit.setMaximumWidth(200)
filter_line_edit.setPlaceholderText('Filter name')
filter_line_edit.setToolTip('Filter name optionally using regular expressions (' + QKeySequence(QKeySequence.Find).toString() + ')')
filter_line_edit.textChanged.connect(filter_changed)
tool_bar.addWidget(filter_line_edit)
# actions to toggle visibility of available sizes/columns
def action_toggled(index):
column = 2 + index
table_view.setColumnHidden(column, not table_view.isColumnHidden(column))
table_view.resizeColumnsToContents()
table_view.resizeRowsToContents()
signal_mapper = QSignalMapper()
for i, size in enumerate(all_sizes):
action = QAction('%dx%d' % size, tool_bar)
action.setCheckable(True)
action.setChecked(True)
tool_bar.addAction(action)
action.toggled.connect(signal_mapper.map)
signal_mapper.setMapping(action, i)
# set tool tip and handle key sequence
tool_tip = 'Toggle visibility of column'
if i < 10:
digit = ('%d' % (i + 1))[-1]
tool_tip += ' (%s)' % QKeySequence('Ctrl+%s' % digit).toString()
action.setToolTip(tool_tip)
signal_mapper.mapped.connect(action_toggled)
# label columns
header_labels = ['context', 'name']
for width, height in all_sizes:
header_labels.append('%dx%d' % (width, height))
item_model.setColumnCount(len(header_labels))
item_model.setHorizontalHeaderLabels(header_labels)
# fill rows
item_model.setRowCount(len(icons))
for row, icon_data in enumerate(icons):
# context
item = QStandardItem(icon_data['context'])
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, 0, item)
# icon name
item = QStandardItem(icon_data['icon_name'])
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, 1, item)
for index_in_all_sizes, size in enumerate(all_sizes):
column = 2 + index_in_all_sizes
if size in icon_data['sizes']:
# icon as pixmap to keep specific size
item = QStandardItem('')
pixmap = icon_data['icon'].pixmap(size[0], size[1])
item.setData(pixmap, Qt.DecorationRole)
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, column, item)
else:
# single space to be sortable against icons
item = QStandardItem(' ')
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, column, item)
table_view.resizeColumnsToContents()
# manually set row heights because resizeRowsToContents is not working properly
for row, icon_data in enumerate(icons):
if len(icon_data['sizes']) > 0:
max_size = icon_data['sizes'][-1]
table_view.setRowHeight(row, max_size[1])
# enable focus find (ctrl+f) and toggle columns (ctrl+NUM)
def main_window_keyPressEvent(self, event, old_keyPressEvent=QMainWindow.keyPressEvent):
if event.matches(QKeySequence.Find):
filter_line_edit.setFocus()
return
if event.modifiers() == Qt.ControlModifier and event.key() >= Qt.Key_0 and event.key() <= Qt.Key_9:
index = event.key() - Qt.Key_1
if event.key() == Qt.Key_0:
index += 10
action = signal_mapper.mapping(index)
if action:
action.toggle()
return
old_keyPressEvent(self, event)
main_window.keyPressEvent = new.instancemethod(main_window_keyPressEvent, table_view, None)
# enable copy (ctrl+c) name of icon to clipboard
def table_view_keyPressEvent(self, event, old_keyPressEvent=QTableView.keyPressEvent):
if event.matches(QKeySequence.Copy):
selection_model = self.selectionModel()
if selection_model.hasSelection():
index = selection_model.selectedRows()[0]
source_index = self.model().mapToSource(index)
item = self.model().sourceModel().item(source_index.row(), 1)
icon_name = item.data(Qt.EditRole)
app.clipboard().setText(icon_name.toString())
return
old_keyPressEvent(self, event)
table_view.keyPressEvent = new.instancemethod(table_view_keyPressEvent, table_view, None)
print 'Icon Theme: ', QIcon.themeName()
print 'Theme Search Paths:'
for item in QIcon.themeSearchPaths():
print item
main_window.showMaximized()
return app.exec_()
def main(icon_spec):
app = QApplication(sys.argv)
main_window = QMainWindow()
def sigint_handler(*args):
main_window.close()
signal.signal(signal.SIGINT, sigint_handler)
# the timer enables triggering the sigint_handler
signal_timer = QTimer()
signal_timer.start(100)
signal_timer.timeout.connect(lambda: None)
tool_bar = QToolBar()
main_window.addToolBar(Qt.TopToolBarArea, tool_bar)
table_view = QTableView()
table_view.setSelectionBehavior(QAbstractItemView.SelectRows)
table_view.setSelectionMode(QAbstractItemView.SingleSelection)
table_view.setSortingEnabled(True)
main_window.setCentralWidget(table_view)
proxy_model = QSortFilterProxyModel()
proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive)
proxy_model.setFilterKeyColumn(1)
table_view.setModel(proxy_model)
proxy_model.layoutChanged.connect(table_view.resizeRowsToContents)
item_model = QStandardItemModel()
proxy_model.setSourceModel(item_model)
# get all icons and their available sizes
QIcon.setThemeName("gnome")
icons = []
all_sizes = set([])
for context, icon_names in icon_spec:
for icon_name in icon_names:
icon = QIcon.fromTheme(icon_name)
sizes = []
for size in icon.availableSizes():
size = (size.width(), size.height())
sizes.append(size)
all_sizes.add(size)
sizes.sort()
icons.append({
'context': context,
'icon_name': icon_name,
'icon': icon,
'sizes': sizes,
})
all_sizes = list(all_sizes)
all_sizes.sort()
# input field for filter
def filter_changed(value):
proxy_model.setFilterRegExp(value)
table_view.resizeRowsToContents()
filter_line_edit = QLineEdit()
filter_line_edit.setMaximumWidth(200)
filter_line_edit.setPlaceholderText('Filter name')
filter_line_edit.setToolTip(
'Filter name optionally using regular expressions (' +
QKeySequence(QKeySequence.Find).toString() + ')')
filter_line_edit.textChanged.connect(filter_changed)
tool_bar.addWidget(filter_line_edit)
# actions to toggle visibility of available sizes/columns
def action_toggled(index):
column = 2 + index
table_view.setColumnHidden(column,
not table_view.isColumnHidden(column))
table_view.resizeColumnsToContents()
table_view.resizeRowsToContents()
signal_mapper = QSignalMapper()
for i, size in enumerate(all_sizes):
action = QAction('%dx%d' % size, tool_bar)
action.setCheckable(True)
action.setChecked(True)
tool_bar.addAction(action)
action.toggled.connect(signal_mapper.map)
signal_mapper.setMapping(action, i)
# set tool tip and handle key sequence
tool_tip = 'Toggle visibility of column'
if i < 10:
digit = ('%d' % (i + 1))[-1]
tool_tip += ' (%s)' % QKeySequence('Ctrl+%s' % digit).toString()
action.setToolTip(tool_tip)
signal_mapper.mapped.connect(action_toggled)
# label columns
header_labels = ['context', 'name']
for width, height in all_sizes:
header_labels.append('%dx%d' % (width, height))
item_model.setColumnCount(len(header_labels))
item_model.setHorizontalHeaderLabels(header_labels)
# fill rows
item_model.setRowCount(len(icons))
for row, icon_data in enumerate(icons):
# context
item = QStandardItem(icon_data['context'])
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, 0, item)
# icon name
item = QStandardItem(icon_data['icon_name'])
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, 1, item)
for index_in_all_sizes, size in enumerate(all_sizes):
column = 2 + index_in_all_sizes
if size in icon_data['sizes']:
# icon as pixmap to keep specific size
item = QStandardItem('')
pixmap = icon_data['icon'].pixmap(size[0], size[1])
item.setData(pixmap, Qt.DecorationRole)
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, column, item)
else:
# single space to be sortable against icons
item = QStandardItem(' ')
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, column, item)
table_view.resizeColumnsToContents()
# manually set row heights because resizeRowsToContents is not working properly
for row, icon_data in enumerate(icons):
if len(icon_data['sizes']) > 0:
max_size = icon_data['sizes'][-1]
table_view.setRowHeight(row, max_size[1])
# enable focus find (ctrl+f) and toggle columns (ctrl+NUM)
def main_window_keyPressEvent(self,
event,
old_keyPressEvent=QMainWindow.keyPressEvent):
if event.matches(QKeySequence.Find):
filter_line_edit.setFocus()
return
if event.modifiers() == Qt.ControlModifier and event.key(
) >= Qt.Key_0 and event.key() <= Qt.Key_9:
index = event.key() - Qt.Key_1
if event.key() == Qt.Key_0:
index += 10
action = signal_mapper.mapping(index)
if action:
action.toggle()
return
old_keyPressEvent(self, event)
main_window.keyPressEvent = new.instancemethod(main_window_keyPressEvent,
table_view, None)
# enable copy (ctrl+c) name of icon to clipboard
def table_view_keyPressEvent(self,
event,
old_keyPressEvent=QTableView.keyPressEvent):
if event.matches(QKeySequence.Copy):
selection_model = self.selectionModel()
if selection_model.hasSelection():
index = selection_model.selectedRows()[0]
source_index = self.model().mapToSource(index)
item = self.model().sourceModel().item(source_index.row(), 1)
icon_name = item.data(Qt.EditRole)
app.clipboard().setText(icon_name.toString())
return
old_keyPressEvent(self, event)
table_view.keyPressEvent = new.instancemethod(table_view_keyPressEvent,
table_view, None)
print 'Icon Theme: ', QIcon.themeName()
print 'Theme Search Paths:'
for item in QIcon.themeSearchPaths():
print item
main_window.showMaximized()
return app.exec_()
class charsPanel(QWidget):
def __init__(self, parent=None):
super(charsPanel, self).__init__(parent)
# Do the layout: refresh button and filter popup at the top,
# with a table below.
mainLayout = QVBoxLayout()
self.setLayout(mainLayout)
topLayout = QHBoxLayout()
mainLayout.addLayout(topLayout, 0)
self.refreshButton = QPushButton("Refresh")
self.filterMenu = QComboBox()
topLayout.addWidget(self.refreshButton, 0)
topLayout.addStretch(1)
topLayout.addWidget(self.filterMenu, 0)
self.view = QTableView()
self.view.setCornerButtonEnabled(False)
self.view.setWordWrap(False)
self.view.setAlternatingRowColors(True)
mainLayout.addWidget(self.view, 1)
# Set up the table model/view. Pass to the model a pointer
# to the view so it can query the row under the mouse.
self.model = myTableModel(view=self.view)
# Interpose a sort filter proxy between the view and the model.
self.proxy = mySortFilterProxy(self)
self.proxy.setSourceModel(self.model)
self.view.setModel(self.proxy)
# Hook up the refresh button clicked signal to refresh below
self.connect(self.refreshButton, SIGNAL("clicked()"), self.refresh)
# Populate the filter popup with rows:
# 0 : All - no filter
# 1 : not 7-bit - show only things not in the 7-bit code
# 2 : not Latin-1 - show only things outside Latin-1
self.filterMenu.addItem(QString("All"))
self.filterMenu.addItem(QString("\u00ac" + " 7-bit"))
self.filterMenu.addItem(QString("\u00ac" + " Latin-1"))
# The filters refer to these properties, called with a QChar C
self.lambdaAll = lambda C: True
self.lambdaNotAscii = lambda C: (C.unicode() < 32) or (C.unicode() > 126)
self.lambdaNotLatin = lambda C: (C.toLatin1() == b"\x00")
self.filterLambda = self.lambdaAll
# Connect a user-selection in the popup to our filter method.
self.connect(self.filterMenu, SIGNAL("activated(int)"), self.filter)
# Connect doubleclicked from our table view to self.findThis
self.connect(self.view, SIGNAL("doubleClicked(QModelIndex)"), self.findThis)
# Connect the model reset signals to functions to place and clear
# a status message.
self.connect(self.model, SIGNAL("modelAboutToBeReset()"), self.sigResetStarting)
self.connect(self.model, SIGNAL("modelReset()"), self.sigResetOver)
# This slot receives a double-click on the table. Figure out which
# character it is and get the Find panel set up to search for it.
def findThis(self, qmi):
rep = None
if qmi.column() == 3:
# doubleclick in entity column, put entity in the replace field
rep = qmi.data(Qt.DisplayRole).toString()
if qmi.column() != 0:
# get reference to column 0
qmi = qmi.sibling(qmi.row(), 0)
qs = qmi.data(Qt.DisplayRole).toString()
# Call for a find with respect case on, whole word and regex off
IMC.findPanel.censusFinder(qs, rep, False, False)
# this slot gets the activated(row) signal from the combo-box.
# Based on the row, set self.filterLambda to a lambda that will
# accept or reject a given QChar value.
def filter(self, row):
if row == 1:
self.filterLambda = self.lambdaNotAscii
elif row == 2:
self.filterLambda = self.lambdaNotLatin
else:
self.filterLambda = self.lambdaAll
self.model.reset()
# This slot receives the main window's docWillChange signal.
# It comes with a file path but we can ignore that.
def docWillChange(self):
# self.view.setSortingEnabled(False)
self.model.beginResetModel()
# Subroutine to reset the visual appearance of the table view,
# invoked on table reset or docHasChanged because on instantiation
# we have no data until a file is opened.
def setUpTableView(self):
self.view.resizeColumnsToContents()
self.view.horizontalHeader().setStretchLastSection(True)
self.view.resizeRowsToContents()
self.view.setSortingEnabled(True)
# This slot receives the main window's docHasChanged signal.
# Let the table view populate with all-new metadata (or empty
# data if the command was File>New).
def docHasChanged(self):
self.model.endResetModel()
self.setUpTableView()
# This slot receives the click of the refresh button. Tell the
# model we are resetting everything so the view will suck up new
# data. Then call our editor to rebuild the metadata.
def refresh(self):
# self.view.setSortingEnabled(False)
self.model.beginResetModel()
IMC.editWidget.rebuildMetadata()
self.model.endResetModel()
self.setUpTableView()
# The model emits signals when it is starting to rebuild the table
# and when it has finished rebuilding the table. Use these to put up
# a status message, as the wait can be significant.
def sigResetStarting(self):
pqMsgs.showStatusMsg(QString("Rebuilding Character Table..."))
def sigResetOver(self):
pqMsgs.clearStatusMsg()
class DetailedProgressDialog(QDialog):
def __init__(self, parent, states):
super(DetailedProgressDialog, self).__init__(parent)
self.setWindowTitle("Realization Progress")
layout = QGridLayout(self)
self.detailed_progress_widget = DetailedProgress(states, self)
self.overview_label = QLabel("Realizations")
self.single_view = QTableView()
self.single_view.setModel(SingleProgressModel(self.single_view))
self.single_view_label = QLabel("Realization details")
self.detailed_progress_widget.clicked.connect(self.show_selection)
layout.addWidget(self.single_view_label, 0, 0)
layout.addWidget(self.overview_label, 0, 1)
layout.addWidget(self.single_view, 1, 0)
layout.addWidget(self.detailed_progress_widget, 1, 1)
self.detailed_progress_widget.show()
self.setLayout(layout)
self.layout().setColumnStretch(0, 1)
self.layout().setColumnStretch(1, 2)
self.progress = None
self.selected_realization = None
self.resize(parent.width(), parent.height())
def set_progress(self, progress, iteration):
self.progress = progress
self.detailed_progress_widget.set_progress(progress, iteration)
self.overview_label.setText(
"Realizations for iteration {}".format(iteration))
self.update_single_view()
self.update()
def show_selection(self, iens):
if not self.progress:
return
self.selected_realization = iens
self.single_view_label.setText("Realization id: {}".format(iens))
self.update_single_view()
def update_single_view(self):
if not self.single_view.isVisible(
) or not self.selected_realization in self.progress:
return
model_data = []
jobs = self.progress[self.selected_realization]
headers = []
for job in jobs:
data = job.dump_data()
row = [str(data[key]) for key in data]
model_data.append(row)
headers = list(data.keys())
self.single_view.model().update_data(headers, model_data)
self.single_view.resizeColumnsToContents()
self.single_view.model().modelReset.emit()
class dlgSelectCuenta( QDialog ):
def __init__( self, parent = None ):
super( dlgSelectCuenta, self ).__init__( parent )
self.padre = parent
self.ctaBancomodel = QSqlQueryModel()
self.ctaBancomodel.setQuery( """
SELECT
b.descripcion as Banco,
cb.ctabancaria as 'No. Cuenta',
tm.simbolo as Moneda,
c.codigo as 'Codigo Contable',
c.idcuenta as Id,
c.descripcion as 'Cuenta Contable',
IF(
con.fecha IS NULL,
LAST_DAY(MIN(d.fechacreacion)),
(MAX(con.fecha) + INTERVAL 1 MONTH))
AS conciliar
FROM cuentasbancarias cb
JOIN bancos b ON cb.idbanco=b.idbanco
JOIN cuentascontables c ON c.idcuenta=cb.idcuentacontable
JOIN tiposmoneda tm ON tm.idtipomoneda=cb.idtipomoneda
LEFT JOIN conciliaciones con ON con.idcuentabancaria=cb.idcuentacontable
LEFT JOIN cuentasxdocumento cd ON cd.idcuenta=c.idcuenta
LEFT JOIN documentos d ON cd.iddocumento = d.iddocumento
WHERE d.iddocumento IS NOT NULL
GROUP BY c.idcuenta
;
""" )
#
# if self.ctaBancomodel.rowCount() == 0 :
# QMessageBox.critical(self,"Cuentas Bancarias","No existe ninguna cuenta bancaria")
# self.destroy()
self.setWindowTitle( u"Elija fecha y cuenta bancaria para la conciliación" )
self.filtermodel = QSortFilterProxyModel()
self.filtermodel.setSourceModel( self.ctaBancomodel )
self.filtermodel.setFilterCaseSensitivity( Qt.CaseInsensitive )
self.filtermodel.setFilterKeyColumn( -1 )
self.tblCuenta = QTableView()
self.tblCuenta.setSelectionMode( QAbstractItemView.SingleSelection )
self.tblCuenta.setSelectionBehavior( QAbstractItemView.SelectRows )
self.tblCuenta.setModel( self.filtermodel )
buttonbox = QDialogButtonBox( QDialogButtonBox.Ok | QDialogButtonBox.Cancel )
self.txtSearch = QLineEdit()
formlayout = QFormLayout()
formlayout.addRow( "&Buscar", self.txtSearch )
self.dtPicker = QDateTimeEdit()
self.dtPicker.setReadOnly( True )
# self.dtPicker.setCalendarPopup(True)
self.dtPicker.setAlignment( Qt.AlignHCenter )
self.dtPicker.setDisplayFormat( "MMMM 'd'el yyyy" )
# self.dtPicker.setMinimumDate(QDate(2009,1,1))
fecha = QDate.currentDate()
self.dtPicker.setDate( QDate( fecha.year(), fecha.month(), fecha.daysInMonth() ) )
fechalayout = QFormLayout()
fechalayout.addRow( "&Fecha", self.dtPicker )
layout = QVBoxLayout()
layout.addLayout( fechalayout )
layout.addWidget( self.tblCuenta )
layout.addLayout( formlayout )
layout.addWidget( buttonbox )
self.setLayout( layout )
self.setMinimumWidth( 400 )
buttonbox.accepted.connect( self.aceptar )
buttonbox.rejected.connect( self.reject )
self.txtSearch.textChanged[unicode].connect( self.updateFilter )
self.tblCuenta.selectionModel().currentChanged[QModelIndex, QModelIndex].connect( self.on_tblCuenta_currentChanged )
self.setModal( True )
self.setWindowFlags( Qt.Dialog | Qt.MSWindowsFixedSizeDialogHint | Qt.WindowTitleHint )
self.show()
self.tblCuenta.setFocus()
self.tblCuenta.selectRow( 0 )
self.tblCuenta.setColumnHidden( 4, True )
self.tblCuenta.setColumnHidden( 5, True )
self.tblCuenta.setColumnHidden( 6, True )
self.tblCuenta.horizontalHeader().setStretchLastSection( True )
self.tblCuenta.resizeColumnsToContents()
@property
def data( self ):
data = {}
fila = self.tblCuenta.selectionModel().currentIndex().row()
fecha = self.dtPicker.date()
data['banco'] = self.filtermodel.index( fila, 0 ).data().toString()
data['id_cuenta_contable'] = self.filtermodel.index( fila, 4 ).data().toInt()[0]
data['codigo_cuenta_contable'] = self.filtermodel.index( fila, 3 ).data().toString()
data['cuenta_bancaria'] = self.filtermodel.index( fila, 5 ).data().toString()
data['fecha'] = QDate( fecha.year(), fecha.month(), fecha.daysInMonth() )
data['moneda'] = self.filtermodel.index( fila, 2 ).data().toString()
if not QSqlDatabase.database().isOpen() and not QSqlDatabase.open():
raise Exception( QSqlDatabase.lastError() )
query = QSqlQuery()
if not query.exec_( "CALL spSaldoCuenta( %d, %s )" % (
data['id_cuenta_contable'],
QDate( data['fecha'].year(), data['fecha'].month(), data['fecha'].daysInMonth() ).toString( "yyyyMMdd" )
)
):
raise Exception( query.lastError().text() )
query.first()
data['saldo_inicial_libro'] = Decimal( query.value( 0 ).toString() )
return data
def aceptar( self ):
fecha = QDate.currentDate()
fecha = QDate( fecha.year(), fecha.month(), fecha.daysInMonth() )
if self.dtPicker.date() > fecha:
QMessageBox.information( None, "Cuentas Bancarias", "La cuenta seleccionada ya fue conciliada" )
else:
return self.accept()
def exec_( self ):
if self.ctaBancomodel.rowCount() == 0:
QMessageBox.critical( self.padre, "Cuentas Bancarias",
"No existe ninguna cuenta bancaria con movimientos en este mes" )
return self.reject()
else:
return QDialog.exec_( self )
def updateFilter( self, str ):
self.filtermodel.setFilterWildcard( str )
# @pyqtSlot( "QModelIndex" )
# def on_tblCuenta_clicked(self, index):
def on_tblCuenta_currentChanged( self, _current, _previous ):
fila = self.tblCuenta.selectionModel().currentIndex().row()
fecha = self.filtermodel.index( fila, 6 ).data().toDate()
if fecha.toString() != "":
self.dtPicker.setDate( fecha )
else:
fecha = QDate.currentDate()
class FreezeTableWidget(QTableView):
def __init__(self, table_data, headers, parent=None, *args):
"""
Creates two QTableViews one of which is a frozen table while the
other one can scroll behind it.
:param table_data: The data that goes into the tables
:type table_data: List
:param headers: The header data of the tables.
:type headers: List
:param parent: The parent of the QTableView
:type parent: QWidget
:param args:
:type args:
"""
QTableView.__init__(self, parent)
# set the table model
self.table_model = BaseSTDMTableModel(table_data, headers, parent)
# set the proxy model
proxy_model = QSortFilterProxyModel(self)
proxy_model.setSourceModel(self.table_model)
# Assign a data model for TableView
self.setModel(self.table_model)
# frozen_table_view - first column
self.frozen_table_view = QTableView(self)
# Set the model for the widget, fixed column
self.frozen_table_view.setModel(self.table_model)
# Hide row headers
self.frozen_table_view.verticalHeader().hide()
# Widget does not accept focus
self.frozen_table_view.setFocusPolicy(Qt.StrongFocus | Qt.TabFocus
| Qt.ClickFocus)
# The user can not resize columns
self.frozen_table_view.horizontalHeader().\
setResizeMode(QHeaderView.Fixed)
self.frozen_table_view.setObjectName('frozen_table')
self.setSelectionMode(QAbstractItemView.NoSelection)
self.set_style()
# Remove the scroll bar
self.frozen_table_view.setHorizontalScrollBarPolicy(
Qt.ScrollBarAlwaysOff)
self.frozen_table_view.setVerticalScrollBarPolicy(
Qt.ScrollBarAlwaysOff)
# Puts more widgets to the foreground
self.viewport().stackUnder(self.frozen_table_view)
# # Log in to edit mode - even with one click
# Set the properties of the column headings
hh = self.horizontalHeader()
# Text alignment centered
hh.setDefaultAlignment(Qt.AlignCenter)
self.set_column_width()
# Set properties header lines
vh = self.verticalHeader()
vh.setDefaultSectionSize(25) # height lines
# text alignment centered
vh.setDefaultAlignment(Qt.AlignCenter)
vh.setVisible(True)
# Height of rows - as in the main widget
self.frozen_table_view.verticalHeader().\
setDefaultSectionSize(
vh.defaultSectionSize()
)
# Show frozen table view
self.frozen_table_view.show()
# Set the size of him like the main
self.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel)
self.setVerticalScrollMode(QAbstractItemView.ScrollPerPixel)
self.frozen_table_view.setVerticalScrollMode(
QAbstractItemView.ScrollPerPixel)
## select the first column (STR Type)
self.frozen_table_view.selectColumn(0)
self.frozen_table_view.setEditTriggers(
QAbstractItemView.AllEditTriggers)
self.set_size()
self.signals()
def set_size(self):
"""
Sets the size and size policy of the tables.
:return:
:rtype:
"""
size_policy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
size_policy.setHorizontalStretch(0)
size_policy.setVerticalStretch(0)
size_policy.setHeightForWidth(self.sizePolicy().hasHeightForWidth())
self.setSizePolicy(size_policy)
self.setMinimumSize(QSize(55, 75))
self.setMaximumSize(QSize(5550, 5555))
self.SelectionMode(QAbstractItemView.SelectColumns)
# set column width to fit contents
self.frozen_table_view.resizeColumnsToContents()
# set row height
self.frozen_table_view.resizeRowsToContents()
def signals(self):
"""
Connects signals of the tables.
"""
# Connect the headers and scrollbars of
# both tableviews together
self.horizontalHeader().sectionResized.connect(
self.update_section_width)
self.verticalHeader().sectionResized.connect(
self.update_section_height)
self.frozen_table_view.verticalScrollBar(). \
valueChanged.connect(
self.verticalScrollBar().setValue
)
self.verticalScrollBar().valueChanged.connect(
self.frozen_table_view.verticalScrollBar().setValue)
def set_column_width(self):
"""
Sets the column width of the frozen QTableView.
"""
# Set the width of columns
columns_count = self.table_model.columnCount(self)
for col in range(columns_count):
if col == 0:
# Set the size
self.horizontalHeader().resizeSection(col, 60)
# Fix width
self.horizontalHeader().setResizeMode(col, QHeaderView.Fixed)
# Width of a fixed column - as in the main widget
self.frozen_table_view.setColumnWidth(col,
self.columnWidth(col))
elif col == 1:
self.horizontalHeader().resizeSection(col, 150)
self.horizontalHeader().setResizeMode(col, QHeaderView.Fixed)
self.frozen_table_view.setColumnWidth(col,
self.columnWidth(col))
else:
self.horizontalHeader().resizeSection(col, 150)
# Hide unnecessary columns in the
# widget fixed columns
self.frozen_table_view.setColumnHidden(col, True)
def set_style(self):
"""
Sets the style of the frozen table.
"""
# Style frozentable view
self.frozen_table_view.setStyleSheet('''
#frozen_table{
border-top:none;
}
''')
self.shadow = QGraphicsDropShadowEffect(self)
self.shadow.setBlurRadius(5)
self.shadow.setOffset(2)
self.shadow.setYOffset(0)
self.frozen_table_view.setGraphicsEffect(self.shadow)
def add_widgets(self, str_type_id, insert_row):
"""
Adds widget delete into the frozen table.
:param str_type_id: The STR type id of the tenure type combobox
:type str_type_id: Integer
:param insert_row: The row number the widgets to be added.
:type insert_row: Integer
"""
delegate = STRTypeDelegate(str_type_id)
# Set delegate to add combobox under
# social tenure type column
self.frozen_table_view.setItemDelegate(delegate)
self.frozen_table_view.setItemDelegateForColumn(0, delegate)
index = self.frozen_table_view.model().index(insert_row, 0,
QModelIndex())
self.frozen_table_view.model().setData(index, '', Qt.EditRole)
self.frozen_table_view.openPersistentEditor(
self.frozen_table_view.model().index(insert_row, 0))
self.frozen_table_view.openPersistentEditor(
self.frozen_table_view.model().index(insert_row, 1))
def update_section_width(self, logicalIndex, oldSize, newSize):
"""
Updates frozen table column width and geometry.
:param logicalIndex: The section's logical number
:type logicalIndex: Integer
:param oldSize: The old size of the section
:type oldSize: Integer
:param newSize: The new size of the section
:type newSize: Integer
"""
if logicalIndex == 0 or logicalIndex == 1:
self.frozen_table_view.setColumnWidth(logicalIndex, newSize)
self.update_frozen_table_geometry()
def update_section_height(self, logicalIndex, oldSize, newSize):
"""
Updates frozen table column height.
:param logicalIndex: The section's logical number
:type logicalIndex: Integer
:param oldSize: The old size of the section
:type oldSize: Integer
:param newSize: The new size of the section
:type newSize: Integer
"""
self.frozen_table_view.setRowHeight(logicalIndex, newSize)
def resizeEvent(self, event):
"""
Handles the resize event of the frozen table view.
It updates the frozen table view geometry on resize of table.
:param event: The event
:type event: QEvent
"""
QTableView.resizeEvent(self, event)
try:
self.update_frozen_table_geometry()
except Exception as log:
LOGGER.debug(str(log))
def scrollTo(self, index, hint):
"""
Scrolls the view if necessary to ensure that the item at index is
visible. The view will try to position the item according to the
given hint.
:param index: The scroll index
:type index: QModelIndex
:param hint: The scroll hint
:type hint: Integer
"""
if index.column() > 1:
QTableView.scrollTo(self, index, hint)
def update_frozen_table_geometry(self):
"""
Updates the frozen table view geometry.
"""
if self.verticalHeader().isVisible():
self.frozen_table_view.setGeometry(
self.verticalHeader().width() + self.frameWidth(),
self.frameWidth(),
self.columnWidth(0) + self.columnWidth(1),
self.viewport().height() + self.horizontalHeader().height())
else:
self.frozen_table_view.setGeometry(
self.frameWidth(), self.frameWidth(),
self.columnWidth(0) + self.columnWidth(1),
self.viewport().height() + self.horizontalHeader().height())
def move_cursor(self, cursor_action, modifiers):
"""
Override function for correct left to scroll the keyboard.
Returns a QModelIndex object pointing to the next object in the
table view, based on the given cursorAction and keyboard modifiers
specified by modifiers.
:param cursor_action: The cursor action
:type cursor_action: Integer
:param modifiers: Qt.KeyboardModifier value.
:type modifiers: Object
:return: The current cursor position.
:rtype: QModelIndex
"""
current = QTableView.move_cursor(self, cursor_action, modifiers)
if cursor_action == self.MoveLeft and current.column() > 1 and \
self.visualRect(current).topLeft().x() < \
(self.frozen_table_view.columnWidth(0) +
self.frozen_table_view.columnWidth(1)):
new_value = self.horizontalScrollBar().value() + \
self.visualRect(current).topLeft().x() - \
(self.frozen_table_view.columnWidth(0) +
self.frozen_table_view.columnWidth(1))
self.horizontalScrollBar().setValue(new_value)
return current
class QueueDialog(Window):
def __init__(self, base):
Window.__init__(self, base, i18n.get('messages_queue'))
self.setFixedSize(500, 400)
self.last_timestamp = None
self.showed = False
self.list_ = QTableView()
self.list_.setSelectionBehavior(QAbstractItemView.SelectRows)
self.list_.clicked.connect(self.__account_clicked)
self.caption = QLabel()
self.caption.setWordWrap(True)
self.caption.setAlignment(Qt.AlignCenter)
self.estimated_time = QLabel()
self.estimated_time.setWordWrap(True)
self.estimated_time.setAlignment(Qt.AlignCenter)
self.delete_button = QPushButton(i18n.get('delete'))
self.delete_button.setEnabled(False)
self.delete_button.setToolTip(i18n.get('delete_selected_message'))
self.delete_button.clicked.connect(self.__delete_message)
self.clear_button = QPushButton(i18n.get('delete_all'))
self.clear_button.setEnabled(False)
self.clear_button.setToolTip(i18n.get('delete_all_messages_in_queue'))
self.clear_button.clicked.connect(self.__delete_all)
button_box = QHBoxLayout()
button_box.addStretch(1)
button_box.addWidget(self.clear_button)
button_box.addWidget(self.delete_button)
layout = QVBoxLayout()
layout.addWidget(self.list_, 1)
layout.addWidget(self.caption)
layout.addWidget(self.estimated_time)
layout.addLayout(button_box)
layout.setSpacing(5)
layout.setContentsMargins(5, 5, 5, 5)
self.setLayout(layout)
def __account_clicked(self, point):
self.delete_button.setEnabled(True)
self.clear_button.setEnabled(True)
def __delete_message(self):
self.__disable()
selection = self.list_.selectionModel()
index = selection.selectedIndexes()[0]
message = i18n.get('delete_message_from_queue_confirm')
confirmation = self.base.show_confirmation_message(i18n.get('confirm_delete'),
message)
if not confirmation:
self.__enable()
return
self.base.delete_message_from_queue(index.row())
def __delete_all(self):
self.__disable()
message = i18n.get('clear_message_queue_confirm')
confirmation = self.base.show_confirmation_message(i18n.get('confirm_delete'),
message)
if not confirmation:
self.__enable()
return
self.base.clear_queue()
def __enable(self):
self.list_.setEnabled(True)
self.delete_button.setEnabled(False)
if len(self.base.core.list_statuses_queue()) > 0:
self.clear_button.setEnabled(True)
else:
self.clear_button.setEnabled(False)
def __disable(self):
self.list_.setEnabled(False)
self.delete_button.setEnabled(False)
self.clear_button.setEnabled(False)
def __on_timeout(self):
now = int(time.time())
interval = self.base.core.get_queue_interval() * 60
if self.last_timestamp:
est_time = ((self.last_timestamp + interval) - now) / 60
else:
est_time = 0
humanized_est_time = self.base.humanize_time_intervals(est_time)
next_message = ' '.join([i18n.get('next_message_should_be_posted_in'), humanized_est_time])
if len(self.base.core.list_statuses_queue()) == 0:
self.estimated_time.setText('')
else:
self.estimated_time.setText(next_message)
def start(self):
self.timer = QTimer()
self.timer.timeout.connect(self.__on_timeout)
self.timer.start(60000)
def closeEvent(self, event=None):
if event:
event.ignore()
self.hide()
self.showed = False
def show(self):
if self.showed:
self.raise_()
return
self.update()
Window.show(self)
self.showed = True
def update(self):
model = QStandardItemModel()
model.setHorizontalHeaderItem(0, QStandardItem(i18n.get('account')))
model.setHorizontalHeaderItem(1, QStandardItem(i18n.get('message')))
self.list_.setModel(model)
now = int(time.time())
interval = self.base.core.get_queue_interval() * 60
if self.last_timestamp:
est_time = ((self.last_timestamp + interval) - now) / 60
else:
est_time = 0
row = 0
for status in self.base.core.list_statuses_queue():
username = get_username_from(status.account_id)
protocol_image = "%s.png" % get_protocol_from(status.account_id)
item = QStandardItem(QString.fromUtf8(username))
item.setIcon(QIcon(self.base.load_image(protocol_image, True)))
model.setItem(row, 0, item)
model.setItem(row, 1, QStandardItem(QString.fromUtf8(status.text)))
row += 1
humanized_interval = self.base.humanize_time_intervals(self.base.core.get_queue_interval())
humanized_est_time = self.base.humanize_time_intervals(est_time)
warning = i18n.get('messages_will_be_send') % humanized_interval
next_message = ' '.join([i18n.get('next_message_should_be_posted_in'), humanized_est_time])
self.caption.setText(warning)
if row == 0:
self.estimated_time.setText('')
else:
self.estimated_time.setText(next_message)
self.list_.horizontalHeader().setResizeMode(1, QHeaderView.Stretch)
self.list_.resizeColumnsToContents()
self.__enable()
def update_timestamp(self):
if len(self.base.core.list_statuses_queue()) > 0:
self.last_timestamp = int(time.time())
else:
self.last_timestamp = None
class charsPanel(QWidget):
def __init__(self, parent=None):
super(charsPanel, self).__init__(parent)
# Do the layout: refresh button and filter popup at the top,
# with a table below.
mainLayout = QVBoxLayout()
self.setLayout(mainLayout)
topLayout = QHBoxLayout()
mainLayout.addLayout(topLayout, 0)
self.refreshButton = QPushButton("Refresh")
self.filterMenu = QComboBox()
topLayout.addWidget(self.refreshButton, 0)
topLayout.addStretch(1)
topLayout.addWidget(self.filterMenu, 0)
self.view = QTableView()
self.view.setCornerButtonEnabled(False)
self.view.setWordWrap(False)
self.view.setAlternatingRowColors(True)
mainLayout.addWidget(self.view, 1)
# Set up the table model/view. Pass to the model a pointer
# to the view so it can query the row under the mouse.
self.model = myTableModel(view=self.view)
#Interpose a sort filter proxy between the view and the model.
self.proxy = mySortFilterProxy(self)
self.proxy.setSourceModel(self.model)
self.view.setModel(self.proxy)
# Hook up the refresh button clicked signal to refresh below
self.connect(self.refreshButton, SIGNAL("clicked()"), self.refresh)
# Populate the filter popup with rows:
# 0 : All - no filter
# 1 : not 7-bit - show only things not in the 7-bit code
# 2 : not Latin-1 - show only things outside Latin-1
self.filterMenu.addItem(QString(u"All"))
self.filterMenu.addItem(QString(u"\u00ac" + u" 7-bit"))
self.filterMenu.addItem(QString(u"\u00ac" + u" Latin-1"))
# The filters refer to these properties, called with a QChar C
self.lambdaAll = lambda C: True
self.lambdaNotAscii = lambda C: (C.unicode() < 32) or (C.unicode() >
126)
self.lambdaNotLatin = lambda C: (C.toLatin1() == b'\x00')
self.filterLambda = self.lambdaAll
# Connect a user-selection in the popup to our filter method.
self.connect(self.filterMenu, SIGNAL("activated(int)"), self.filter)
# Connect doubleclicked from our table view to self.findThis
self.connect(self.view, SIGNAL("doubleClicked(QModelIndex)"),
self.findThis)
# Connect the model reset signals to functions to place and clear
# a status message.
self.connect(self.model, SIGNAL("modelAboutToBeReset()"),
self.sigResetStarting)
self.connect(self.model, SIGNAL("modelReset()"), self.sigResetOver)
# This slot receives a double-click on the table. Figure out which
# character it is and get the Find panel set up to search for it.
def findThis(self, qmi):
rep = None
if qmi.column() == 3:
# doubleclick in entity column, put entity in the replace field
rep = qmi.data(Qt.DisplayRole).toString()
if qmi.column() != 0:
# get reference to column 0
qmi = qmi.sibling(qmi.row(), 0)
qs = qmi.data(Qt.DisplayRole).toString()
# Call for a find with respect case on, whole word and regex off
IMC.findPanel.censusFinder(qs, rep, False, False)
# this slot gets the activated(row) signal from the combo-box.
# Based on the row, set self.filterLambda to a lambda that will
# accept or reject a given QChar value.
def filter(self, row):
if row == 1: self.filterLambda = self.lambdaNotAscii
elif row == 2: self.filterLambda = self.lambdaNotLatin
else: self.filterLambda = self.lambdaAll
self.model.reset()
# This slot receives the main window's docWillChange signal.
# It comes with a file path but we can ignore that.
def docWillChange(self):
#self.view.setSortingEnabled(False)
self.model.beginResetModel()
# Subroutine to reset the visual appearance of the table view,
# invoked on table reset or docHasChanged because on instantiation
# we have no data until a file is opened.
def setUpTableView(self):
self.view.resizeColumnsToContents()
self.view.horizontalHeader().setStretchLastSection(True)
self.view.resizeRowsToContents()
self.view.setSortingEnabled(True)
# This slot receives the main window's docHasChanged signal.
# Let the table view populate with all-new metadata (or empty
# data if the command was File>New).
def docHasChanged(self):
self.model.endResetModel()
self.setUpTableView()
# This slot receives the click of the refresh button. Tell the
# model we are resetting everything so the view will suck up new
# data. Then call our editor to rebuild the metadata.
def refresh(self):
#self.view.setSortingEnabled(False)
self.model.beginResetModel()
IMC.editWidget.rebuildMetadata()
self.model.endResetModel()
self.setUpTableView()
# The model emits signals when it is starting to rebuild the table
# and when it has finished rebuilding the table. Use these to put up
# a status message, as the wait can be significant.
def sigResetStarting(self):
pqMsgs.showStatusMsg(QString(u"Rebuilding Character Table..."))
def sigResetOver(self):
pqMsgs.clearStatusMsg()
class MainWindow(QMainWindow):
"""
Initialization
"""
def __init__(self, rulesModel, logoFnam, *args):
QMainWindow.__init__(self, *args)
self.rulesModel = rulesModel
self.rulesModel.dataChanged.connect(self._statusRefresh)
self.cancelled = True # for to handle win close box the same as Cancel button
self.mainHSplit = QSplitter(self) # data | buttons
self.mainHSplit.setChildrenCollapsible(False)
self.setCentralWidget(self.mainHSplit)
self.mainVSplit = QSplitter(Qt.Vertical)
self.mainVSplit.setChildrenCollapsible(False)
self.mainHSplit.addWidget(self.mainVSplit)
self._drawRules()
self.mainVSplit.addWidget(self.rulesView)
self.condActSplit = QSplitter()
self.condActSplit.setChildrenCollapsible(False)
self._drawCondAct()
self.mainVSplit.addWidget(self.condActSplit)
# let rules view resize vertically two times faster than cond/action view
self.rulesView.setSizeIncrement(self.rulesView.sizeIncrement().width(),
2 * self.condView.sizeIncrement().height())
self._drawButtons(logoFnam)
self.setStatusBar(QStatusBar())
self.condView.horizontalHeader().setCascadingSectionResizes(True)
self.rulesView.selectRow(0)
def _drawRules(self):
self.rulesView = QTableView()
self.rulesView.setModel(self.rulesModel)
self.rulesView.setEditTriggers(QAbstractItemView.AllEditTriggers)
self.rulesView.setSelectionBehavior(QAbstractItemView.SelectRows)
self.rulesView.setSelectionMode(QAbstractItemView.SingleSelection)
self.rulesView.horizontalHeader().setStretchLastSection(True)
self.rulesView.resizeColumnsToContents()
#self.rulesView.verticalHeader().setMovable(True) # row remapping - see QHeaderView.logicalIndex()
#self.rulesView.verticalHeader().setCascadingSectionResizes(True) # takes space from next row
self.rulesView.selectionModel().currentRowChanged.connect(self._ruleRowChanged)
self.rulesView.verticalHeader().sectionResized[int,int,int].connect(self._ruleRowHeightChanged)
def _drawCondAct(self):
if getattr(self, 'condGB', None):
m_settings.setValue('spl_condAct', self.condActSplit.saveState())
self.condGB.deleteLater() # or .destroy()
del self.condGB
self.actionGB.deleteLater()
del self.actionGB
row = self._ruleCurrRow()
rcount = self.rulesModel.rowCount()
self.condGB = QGroupBox(self.tr('Conditions'))
self.condView = QTableView()
conds = self.rulesModel.ruleConditions(row) if row in range(rcount) \
else []
self.condModel = ConditionsModel(conds, self.rulesModel)
self.condModel.dataChanged.connect(self._codeFragChanged)
self.condView.setModel(self.condModel)
self.condTypeDelegate = ComboBoxDelegate(Condition._types._typeCaptions)
self.condView.setItemDelegateForColumn(0, self.condTypeDelegate)
self.condView.setEditTriggers(QAbstractItemView.AllEditTriggers)
self.condView.setSelectionBehavior(QAbstractItemView.SelectRows)
self.condView.setSelectionMode(QAbstractItemView.SingleSelection)
self.condView.horizontalHeader().setStretchLastSection(True)
self.condView.resizeColumnsToContents()
self.condView.selectionModel().currentRowChanged.connect(self._statusRefresh)
vbox = QVBoxLayout()
vbox.addWidget(self.condView)
self.condGB.setLayout(vbox)
self.condActSplit.addWidget(self.condGB)
self.actionGB = QGroupBox(self.tr('Actions'))
self.actionView = QTableView() # parent = self.actionGB)
actions = self.rulesModel.ruleActions(row) if row in range(rcount) \
else []
self.actionModel = ActionsModel(actions, self.rulesModel)
self.actionModel.dataChanged.connect(self._codeFragChanged)
self.actionView.setModel(self.actionModel)
self.actionTypeDelegate = ComboBoxDelegate(Action._types._typeCaptions)
self.actionView.setItemDelegateForColumn(0, self.actionTypeDelegate)
self.actionView.setEditTriggers(QAbstractItemView.AllEditTriggers)
self.actionView.setSelectionBehavior(QAbstractItemView.SelectRows)
self.actionView.setSelectionMode(QAbstractItemView.SingleSelection)
self.actionView.horizontalHeader().setStretchLastSection(True)
self.actionView.resizeColumnsToContents()
self.actionView.selectionModel().currentRowChanged.connect(self._statusRefresh)
vbox = QVBoxLayout()
vbox.addWidget(self.actionView)
self.actionGB.setLayout(vbox)
self.condActSplit.addWidget(self.actionGB)
self.condActSplit.restoreState(m_settings.value('spl_condAct').toByteArray())
def _drawButton(self, vbox, caption, slot, ena = False):
but = QPushButton(self.tr(caption))
but.setEnabled(ena)
but.clicked.connect(getattr(self, slot))
vbox.addWidget(but) # add to VBoxLayout
return but
def _drawButtons(self, logoFnam):
gbox = QGroupBox()
spol = QSizePolicy()
spol.horizontalPolicy = QSizePolicy.Maximum
gbox.setSizePolicy(spol)
vbox = QVBoxLayout()
if os.path.isfile(logoFnam):
img = QPixmap(logoFnam) #.scaled(64, 64)
lblLogo = QLabel()
lblLogo.setPixmap(img)
lblLogo.setAlignment(Qt.AlignTop | Qt.AlignRight)
vbox.addWidget(lblLogo)
#vbox.addSpacing(3)
self.butSave = self._drawButton(vbox, "M&odify", 'closeSave')
font = QFont()
font.setBold(True)
self.butSave.setFont(font)
self.butCancel = self._drawButton(vbox, "Cancel", 'closeCancel', True)
vbox.addSpacing(36)
self.butAddRule = self._drawButton(vbox, "Add Rule", 'addRule', True)
self.butCopyRule = self._drawButton(vbox, "Copy Rule", 'copyRule')
self.butDelRule = self._drawButton(vbox, "Delete Rule", 'delRule')
self.butMoveRuleUp = self._drawButton(vbox, "Move Rule Up", 'moveRuleUp')
self.butMoveRuleDn = self._drawButton(vbox, "Move Rule Down", 'moveRuleDown')
vbox.addSpacing(24)
self.butAddCond = self._drawButton(vbox, "Add Condition", 'addCond')
self.butDelCond = self._drawButton(vbox, "Delete Condition", 'delCond')
vbox.addSpacing(15)
self.butAddAction = self._drawButton(vbox, "Add Action", 'addAction')
self.butDelAction = self._drawButton(vbox, "Delete Action", 'delAction')
gbox.setLayout(vbox)
self.mainHSplit.addWidget(gbox)
"""
Internal Bindings Signal Receivers
"""
# main win close events
# .. (cancel closing with event.ignore(); QMainWindow calls event.accept())
@pyqtSlot(QCloseEvent)
def closeEvent(self, event):
self._saveAppState()
# save rules if not empty and user clicked Modified/Save button
if self.rulesModel.rowCount() > 0 and not self.cancelled:
text = self.rulesModel.getRawRules().validate()
if text:
self.cancelled = True
QMessageBox.information(self, APP_TITLE,
self.tr("Validation failed because of:<p><p>") + text)
event.ignore()
return # RETURN - cancel app closing ######
self.rulesModel.saveScript()
# accept window closing
QMainWindow.closeEvent(self, event)
# quit application
m_app.quit()
@pyqtSlot()
def _statusRefresh(self): # dis/enable buttons, display view selections
ruleRow = self._ruleCurrRow()
condRow = self._condCurrRow()
actionRow = self._actionCurrRow()
self.butSave.setEnabled(self.rulesModel.isModified())
ruleCnt = self.rulesModel.rowCount()
self.butCopyRule.setEnabled(ruleRow >= 0)
self.butDelRule.setEnabled(ruleRow >= 0)
self.butMoveRuleUp.setEnabled(ruleRow > 0)
self.butMoveRuleDn.setEnabled(ruleRow >= 0 and ruleRow + 1 < ruleCnt)
self.butAddCond.setEnabled(ruleRow >= 0)
self.butDelCond.setEnabled(condRow >= 0)
self.butAddAction.setEnabled(ruleRow >= 0)
self.butDelAction.setEnabled(actionRow >= 0)
# display currently selected list rows in the status bar - if empty
if ruleRow >= 0 and False: # replace False with ~self.statusBar().isEmpty()?!?!?
text = str(self.tr("Selected Rule: {ruleI}"))\
.format(ruleI = ruleRow + 1)
if condRow >= 0:
text += " " \
+ str(self.tr("Selected Condition: {typeI}"))\
.format(typeI = condRow + 1)
if actionRow >= 0:
text += " " \
+ str(self.tr("Selected Action: {typeI}"))\
.format(typeI = actionRow + 1)
self.statusBar().showMessage(text, 3000)
@pyqtSlot(int,int,int)
def _ruleRowHeightChanged(self, section, oldsize, newsize):
hdr = self.rulesView.verticalHeader()
for row in range(hdr.count()):
if row != section:
hdr.resizeSection(row, newsize)
@pyqtSlot()
def _ruleRowChanged(self):
self._drawCondAct()
self._statusRefresh()
@pyqtSlot()
def _codeFragChanged(self): # refresh the rules list columns Conditions and Actions
row = self._ruleCurrRow()
leftColIndex = self.rulesModel.index(row, 2, QModelIndex())
rightColIndex = self.rulesModel.index(row, 3, QModelIndex())
self.rulesView.dataChanged(leftColIndex, rightColIndex)
self._statusRefresh()
"""
User Action Signal Receivers
"""
@pyqtSlot()
def closeSave(self):
self.cancelled = False
self.close()
@pyqtSlot()
def closeCancel(self):
self.cancelled = True
self.close()
@pyqtSlot()
def addRule(self):
row = self._ruleCurrRow()
self.rulesModel.insertRow(row)
self.rulesView.selectRow(row)
self._statusRefresh()
@pyqtSlot()
def copyRule(self):
row = self._ruleCurrRow()
self.rulesModel.setSourceRowForNextAdd(row)
self.rulesModel.insertRow(row)
self.rulesView.selectRow(row)
self._statusRefresh()
@pyqtSlot()
def delRule(self):
self.rulesModel.removeRow(self._ruleCurrRow())
self._statusRefresh()
@pyqtSlot()
def moveRuleUp(self):
row = self._ruleCurrRow()
self.rulesModel.moveRule(row, -1)
self._statusRefresh()
@pyqtSlot()
def moveRuleDown(self):
row = self._ruleCurrRow()
self.rulesModel.moveRule(row)
self._statusRefresh()
@pyqtSlot()
def addCond(self):
cnt = self.condModel.rowCount()
self.condModel.insertRow(cnt)
self.condView.selectRow(cnt)
self._statusRefresh()
@pyqtSlot()
def delCond(self):
self.condModel.removeRow(self._condCurrRow())
self._statusRefresh()
@pyqtSlot()
def addAction(self):
cnt = self.actionModel.rowCount()
self.actionModel.insertRow(cnt)
self.actionView.selectRow(cnt)
self._statusRefresh()
@pyqtSlot()
def delAction(self):
self.actionModel.removeRow(self._actionCurrRow())
self._statusRefresh()
"""
Helping Methods
"""
def _ruleCurrRow(self):
#idxs = self.rulesView.selectedIndexes()
#return idxs[0].row() if idxs else -1
return self.rulesView.currentIndex().row()
def _condCurrRow(self):
return self.condView.currentIndex().row()
def _actionCurrRow(self):
return self.actionView.currentIndex().row()
# main win save/restore
def _saveAppState(self):
m_app.processEvents()
# save win geometry and splitter positions
_UI_SAVE(self, 'win_geometry')
_UI_SAVE(self.mainHSplit, 'spl_mainH')
_UI_SAVE(self.mainVSplit, 'spl_mainV')
_UI_SAVE(self.condActSplit, 'spl_condAct')
#_UI_SAVE(self.condView.horizontalHeader(), 'tvh_condHdr')
def _restoreAppState(self):
try: # will fail on first app startup after installation
# restore last win position, -size and 3 splitter positions
_UI_RESTORE(self, 'win_geometry')
_UI_RESTORE(self.mainHSplit, 'spl_mainH')
_UI_RESTORE(self.mainVSplit, 'spl_mainV')
_UI_RESTORE(self.condActSplit, 'spl_condAct')
#_UI_RESTORE(self.condView.horizontalHeader(), 'tvh_condHdr')
except: # first start
screenWidth = QApplication.desktop().width()
screenHeight = QApplication.desktop().height()
self.setGeometry(screenWidth / 9, screenHeight / 12,
screenWidth / 1.26, screenHeight / 1.56)
class MobileWidget(QWidget):
"""
Mobile widget
"""
RefreshScreen = pyqtSignal()
RefreshAutomatic = pyqtSignal(bool)
TapOn = pyqtSignal(int, int)
def __init__(self, parent=None):
"""
Constructor
"""
super(MobileWidget, self).__init__(parent)
self.origWidth = 0
self.origHeight = 0
self.imagePath = None
self.createActions()
self.createWidget()
self.createToolbar()
self.center()
def createActions(self):
"""
Create qt actions
"""
self.refreshAction = QtHelper.createAction(self,
self.tr("&Refresh"),
self.refreshScreen,
icon=None)
self.refreshAction.setEnabled(False)
self.copyAction = QtHelper.createAction(self,
self.tr("&Copy"),
self.copyItem,
icon=None)
def createWidget(self):
"""
Create qt widget
"""
self.screenResolutionLabel = QLabel(self)
self.screenTapLabel = QLabel(self)
mobileLayout = QVBoxLayout()
self.mobileDockToolbar = QToolBar(self)
self.mobileDockToolbar.setStyleSheet("QToolBar { border: 0px }")
self.mobileDockToolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
self.mobileImageLabel = QLabel(self)
self.mobileImageLabel.setMouseTracking(True)
self.mobileImageLabel.installEventFilter(self)
self.mobileImageLabel.setScaledContents(True)
self.mobileImageLabel.mousePressEvent = self.pixelSelect
self.refreshCheckbox = QCheckBox("Automatic Refresh", self)
self.refreshCheckbox.setEnabled(False)
self.refreshCheckbox.stateChanged.connect(self.onRefreshChanged)
self.clickCheckbox = QCheckBox("Enable Tap", self)
self.clickCheckbox.setEnabled(False)
self.model = DomModel(QDomDocument(), self)
self.mobileTreeView = QTreeView(self)
self.mobileTreeView.setMinimumWidth(300)
self.mobileTreeView.setModel(self.model)
self.mobileTreeView.clicked.connect(self.onTreeViewClicked)
header = ["Attribute", "Value"]
self.tableModel = MyTableModel(self, [], header)
self.mobileTableView = QTableView(self)
self.mobileTableView.setSelectionMode(
QAbstractItemView.SingleSelection)
self.mobileTableView.setModel(self.tableModel)
self.mobileTableView.setContextMenuPolicy(Qt.CustomContextMenu)
self.mobileTableView.customContextMenuRequested.connect(
self.onContextMenuEvent)
self.mobileTableView.setMinimumWidth(300)
mobileViewLayout = QHBoxLayout()
mobileViewLayout.addWidget(self.mobileImageLabel)
mobileViewLayout.addWidget(self.mobileTreeView)
mobileViewLayout.addWidget(self.mobileTableView)
mobileLayout.addWidget(self.mobileDockToolbar)
mobileLayout.addLayout(mobileViewLayout)
self.setLayout(mobileLayout)
def createToolbar(self):
"""
Create qt toolbar
"""
self.mobileDockToolbar.setObjectName("Toolbar")
self.mobileDockToolbar.addWidget(self.refreshCheckbox)
self.mobileDockToolbar.addWidget(self.clickCheckbox)
self.mobileDockToolbar.addSeparator()
self.mobileDockToolbar.addAction(self.refreshAction)
self.mobileDockToolbar.addSeparator()
self.mobileDockToolbar.addWidget(self.screenResolutionLabel)
self.mobileDockToolbar.addSeparator()
self.mobileDockToolbar.addWidget(self.screenTapLabel)
self.mobileDockToolbar.addSeparator()
self.mobileDockToolbar.setIconSize(QSize(16, 16))
def center(self):
"""
Center the dialog
"""
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def eventFilter(self, srcEvent, event):
"""
On event filtering
"""
if srcEvent == self.mobileImageLabel:
if event.type() == QEvent.MouseMove:
x = event.pos().x()
y = event.pos().y()
pixmap = self.mobileImageLabel.pixmap()
if pixmap is not None:
x_scaled = int((self.origWidth * x) / pixmap.width())
y_scaled = int((self.origHeight * y) / pixmap.height())
self.mobileImageLabel.setToolTip("%sx%s" %
(x_scaled, y_scaled))
return False
def onContextMenuEvent(self, event):
"""
On context menu event
"""
menu = QMenu(self)
menu.addAction(self.copyAction)
menu.popup(QCursor.pos())
def copyItem(self):
"""
Copy the item
"""
indexes = self.mobileTableView.selectedIndexes()
if len(indexes):
data = self.tableModel.mylist[indexes[0].row()][
indexes[0].column()]
clipboard = QApplication.clipboard()
clipboard.setText(data)
def onTreeViewClicked(self, qindex):
"""
On click in the treeview
"""
item = qindex.internalPointer()
attributes = []
node = item.node()
attributeMap = node.attributes()
nodeName = node.nodeName()
bounds_str = None
for i in range(0, attributeMap.count()):
attribute = attributeMap.item(i)
attributes.append((attribute.nodeName(), attribute.nodeValue()))
if attribute.nodeName() == 'bounds':
bounds_str = attribute.nodeValue()
self.tableModel.mylist = attributes
if sys.version_info > (3, ):
self.tableModel.beginResetModel()
self.tableModel.endResetModel()
else:
self.tableModel.reset()
self.mobileTableView.resizeColumnsToContents()
self.mobileTableView.resizeRowsToContents()
# redraw image with rectangle
if bounds_str is not None:
xy = bounds_str.split('][')[0].split('[')[1]
wh = bounds_str.split('][')[1].split(']')[0]
x, y = xy.split(',')
w, h = wh.split(',')
# get label size
pixmap = self.mobileImageLabel.pixmap()
xlabel = pixmap.width()
ylabel = pixmap.height()
# resize the rectangle
y_scaled = (pixmap.height() * int(y)) / self.origHeight
x_scaled = (pixmap.width() * int(x)) / self.origWidth
h_scaled = (pixmap.height() * (int(h) - int(y))) / self.origHeight
w_scaled = (pixmap.width() * (int(w) - int(x))) / self.origWidth
# finally reload
self.reloadScreen(x=int(x_scaled),
y=int(y_scaled),
w=int(w_scaled),
h=int(h_scaled))
def onDeviceReady(self):
"""
On device ready
"""
self.refreshAction.setEnabled(True)
self.refreshCheckbox.setEnabled(True)
self.clickCheckbox.setEnabled(True)
def refreshScreen(self):
"""
Refresh the screen
"""
self.RefreshScreen.emit()
def onRefreshChanged(self, state):
"""
On refresh changed
"""
if state == Qt.Checked:
self.RefreshAutomatic.emit(True)
else:
self.RefreshAutomatic.emit(False)
def pixelSelect(self, event):
"""
Select pixel to click
"""
position = QPoint(event.pos().x(), event.pos().y())
x = event.pos().x()
y = event.pos().y()
pixmap = self.mobileImageLabel.pixmap()
x_scaled = int((self.origWidth * x) / pixmap.width())
y_scaled = int((self.origHeight * y) / pixmap.height())
self.screenTapLabel.setText("Tap on (%s,%s)" % (x_scaled, y_scaled))
if self.clickCheckbox.isChecked():
self.TapOn.emit(x_scaled, y_scaled)
def drawRectangle(self, x=0, y=0, w=0, h=0):
"""
Draw a rectangle
"""
self.mobileImageLabel.update()
pixmap = self.mobileImageLabel.pixmap()
if pixmap is not None:
p = QPainter(pixmap)
pen = QPen(Qt.red, 2, Qt.SolidLine)
p.setPen(pen)
p.drawRect(x, y, w, h)
p.end()
def reloadScreen(self, x, y, w, h):
"""
Reload the screen
"""
if self.imagePath is not None:
self.updateScreen(filename=self.imagePath,
xmlPath='',
x=x,
y=y,
w=w,
h=h,
reloadMode=True)
def updateScreen(self,
filename,
xmlPath,
x=0,
y=0,
w=0,
h=0,
reloadMode=False):
"""
Update the screen
"""
self.imagePath = filename
if not reloadMode:
self.tableModel.mylist = []
self.tableModel.beginResetModel()
self.tableModel.endResetModel()
pixmap = QPixmap(filename)
if pixmap is not None:
self.origWidth = pixmap.width()
self.origHeight = pixmap.height()
self.screenResolutionLabel.setText(
"Resolution=%sx%s" % (self.origWidth, self.origHeight))
#portrait
if self.origWidth < self.origHeight:
pixmap = pixmap.scaledToHeight(Settings.getInt(
'MobileAndroid', 'resolution-screen-height'),
mode=Qt.SmoothTransformation)
self.mobileImageLabel.setPixmap(pixmap)
else:
pixmap = pixmap.scaledToWidth(Settings.getInt(
'MobileAndroid', 'resolution-screen-width'),
mode=Qt.SmoothTransformation)
self.mobileImageLabel.setPixmap(pixmap)
self.drawRectangle(x=x, y=y, w=w, h=h)
self.resize(pixmap.width(), pixmap.height())
# convert xml to dict
if len(xmlPath):
f = QFile(xmlPath)
if f.open(QIODevice.ReadOnly):
document = QDomDocument()
if document.setContent(f):
newModel = DomModel(document, self)
self.mobileTreeView.setModel(newModel)
self.mobileTreeView.expandAll()
self.mobileTreeView.resizeColumnToContents(0)
f.close()
class DlgSelectInvoice( QDialog ):
def __init__( self, parent = None ):
super( DlgSelectInvoice, self ).__init__( parent )
self.billsmodel = QSqlQueryModel()
query = """
SELECT * FROM (
SELECT
factura.iddocumento,
CONCAT_WS(' ', tdc.descripcion, factura.ndocimpreso) AS 'Numero de Factura',
factura.fechacreacion AS 'Fecha',
p.nombre AS 'Cliente',
-SUM(axd.unidades) -
IFNULL((
SELECT
SUM(axddev.unidades)
FROM documentos devoluciones
JOIN docpadrehijos dpddev ON devoluciones.iddocumento = dpddev.idhijo
JOIN articulosxdocumento axddev ON axddev.iddocumento = devoluciones.iddocumento
WHERE devoluciones.idtipodoc = %d AND dpddev.idpadre = factura.iddocumento
GROUP BY dpddev.idpadre
),0) as unittotal,
p.idpersona,
ca.valorcosto,
ca.idcostoagregado,
tc.tasa,
tc.idtc,
b.nombrebodega AS 'Bodega',
b.idbodega
FROM documentos factura
JOIN bodegas b ON factura.idbodega = b.idbodega
JOIN tiposdoc tdc ON tdc.idtipodoc = factura.idtipodoc
JOIN articulosxdocumento axd ON axd.iddocumento = factura.iddocumento AND factura.idtipodoc = %d
JOIN tiposcambio tc ON tc.idtc = factura.idtipocambio
JOIN personasxdocumento pxd ON pxd.iddocumento = factura.iddocumento
JOIN personas p ON pxd.idpersona = p.idpersona AND p.tipopersona=%d
LEFT JOIN costosxdocumento cxd ON cxd.iddocumento = factura.iddocumento
LEFT JOIN costosagregados ca ON cxd.idcostoagregado = ca.idcostoagregado
JOIN (
SELECT
dpdk.idpadre
FROM documentos kardex
JOIN docpadrehijos dpdk ON kardex.iddocumento = dpdk.idhijo
WHERE kardex.idtipodoc = %d
) as kardex ON kardex.idpadre = factura.iddocumento
GROUP BY factura.iddocumento
) as tbl
WHERE unittotal > 0
""" % ( constantes.IDNC, constantes.IDFACTURA, constantes.CLIENTE, constantes.IDKARDEX )
self.billsmodel.setQuery( query )
self.setWindowTitle( "Seleccione la factura para la devolucion" )
self.filtermodel = QSortFilterProxyModel()
self.filtermodel.setSourceModel( self.billsmodel )
self.filtermodel.setFilterCaseSensitivity( Qt.CaseInsensitive )
self.filtermodel.setFilterKeyColumn( -1 )
iddoc, _ndocimpreso, _fechacreacion, _nombre, total, idpersona, valorcosto, idcosto, tasacambio, idcambio, _nombrebodega, idbodega = range( 12 )
self.tblBills = QTableView()
self.tblBills.setSelectionMode( QAbstractItemView.SingleSelection )
self.tblBills.setSelectionBehavior( QAbstractItemView.SelectRows )
self.tblBills.selectRow( 0 )
self.tblBills.setModel( self.filtermodel )
self.tblBills.setColumnHidden( iddoc, True )
self.tblBills.setColumnHidden( idpersona, True )
self.tblBills.setColumnHidden( total, True )
self.tblBills.setColumnHidden( valorcosto, True )
self.tblBills.setColumnHidden( idcosto, True )
self.tblBills.setColumnHidden( idcambio, True )
self.tblBills.setColumnHidden( tasacambio, True )
self.tblBills.setColumnHidden( idbodega, True )
self.tblBills.horizontalHeader().setStretchLastSection( True )
self.tblBills.resizeColumnsToContents()
buttonbox = QDialogButtonBox( QDialogButtonBox.Ok | QDialogButtonBox.Cancel )
self.txtSearch = QLineEdit()
formlayout = QFormLayout()
formlayout.addRow( "&Buscar", self.txtSearch )
layout = QVBoxLayout()
layout.addWidget( self.tblBills )
layout.addLayout( formlayout )
layout.addWidget( buttonbox )
self.setLayout( layout )
self.setMinimumWidth( 400 )
buttonbox.accepted.connect( self.accept )
buttonbox.rejected.connect( self.reject )
self.txtSearch.textChanged[unicode].connect( self.updateFilter )
#FIXME: Que pasa cuando no hay facturas?
# def exec_( self ):
# if self.billsmodel.rowCount() == 0:
# QMessageBox.critical( None,
# self.trUtf8( "Llantera Esquipulas: Inventario" ),
# self.trUtf8( """No hay facturas a las cuales hacer devoluciones""" ),
# QMessageBox.StandardButtons( \
# QMessageBox.Ok ) )
# self.reject()
# else:
# QDialog.exec_( self )
def updateFilter( self, str ):
self.filtermodel.setFilterWildcard( str )
class ComponentSearchForm():
data_source = None
related_mashups = None
widget = None
table = None
add_btn = None
graph_form = None
highlighted_api = None
highlighted_mashup = None
categoryWindow = None
dataSetListWdiget = None
climateData = None
def show_main_window(self):
# Get datasets from server
data = json.load(urllib2.urlopen(RECO_API_SERVER_ADDR + "/getAllDataSets/"))
# self.climateData = self.loadClimateDataSet(data)
self.climateData = self.parseServerData(data)
self.graph_form = matplotlibWidget()
if self.widget:
self.widget.destroy()
self.widget = None;
self.widget = QWidget()
self.widget.setMinimumSize(1000, 900)
self.widget.setWindowTitle("Recommendation PlugIn")
margin = 30
# Search Feature
self.textboxLabel = QLabel(self.widget)
self.textboxLabel.setText("Describe your goals:")
self.textboxLabel.move(30, 20)
self.textboxLabel.show
self.textbox = QTextEdit(self.widget)
self.textbox.move(30, 45)
self.textbox.setFixedWidth(300)
self.textbox.setFixedHeight(28)
btn_api = QtGui.QPushButton("Recommend Services", self.widget)
btn_api.move(30, 80)
btn_mashup = QtGui.QPushButton("Recommend Workflows", self.widget)
btn_mashup.move(230, 80)
btn_api.clicked.connect(self.api_button_clicked)
btn_mashup.clicked.connect(self.mashups_button_clicked)
self.table = QTableView(self.widget)
self.table.clicked.connect(self.table_clicked)
self.table.setMinimumSize(600, 300)
self.table.resizeColumnsToContents()
self.table.move(30, 120)
# Top Service
self.textboxLabel = QLabel("Top Datasets (Usage)", self.widget)
self.textboxLabel.move(650, 20)
self.textboxLabel.show
self.listWidget = QListWidget(self.widget)
topDatasets = json.load(urllib2.urlopen(RECO_API_SERVER_ADDR + "/getTop10UsedDataset/"))
for topDataset in topDatasets:
id = int(topDataset["datasetID"])
item = QListWidgetItem("{} ({})".format(self.climateData[id]["name"], topDataset["usage"]))
item.setData(Qt.UserRole,self.climateData[id])
self.listWidget.addItem(item)
self.listWidget.move(650, 45)
self.listWidget.resize(280, 380)
self.listWidget.show()
self.listWidget.clicked.connect(lambda: self.dataset_clicked(\
self.listWidget.currentItem().data(Qt.UserRole)))
# Username input box and button for generating recommendations
userTopOffset = 430
self.textboxLabel = QLabel("Enter username for dataset recommendations:", self.widget)
self.textboxLabel.move(30, userTopOffset)
self.textboxLabel.show()
self.userTextbox = QTextEdit(self.widget)
self.userTextbox.move(30, userTopOffset + 30)
self.userTextbox.setFixedWidth(200)
self.userTextbox.setFixedHeight(28)
userBtn = QPushButton("Recommend Datasets", self.widget)
userBtn.move(30 + self.userTextbox.width() + 10, userTopOffset + 30)
#print RECO_API_SERVER_ADDR + "/getTop5RecommendationByUserName/"
## Jan.20 2016
## Change the API names here by shenggu
## According to github.com/cmusv-sc/RecommendationAPIs
##
userBtn.clicked.connect(lambda: self.getRecommendations(RECO_API_SERVER_ADDR + "/getTopKContentBasedCFRecommendedDatasetByUsername",
self.recListFeature))
userBtn.clicked.connect(lambda: self.getRecommendations(RECO_API_SERVER_ADDR + "/getTopKItemBasedCFRecommendedDatasetByUsername",
self.recListItem))
userBtn.clicked.connect(lambda: self.getRecommendations(RECO_API_SERVER_ADDR + "/getTopKUserBasedCFRecommendedDatasetByUsername",
self.recListUser))
userBtn.show()
# Test QlineEdit
# self.userTextbox2 = QLineEdit(self.widget)
# self.userTextbox.move(200, userTopOffset + 30)
# self.userTextbox.setFixedWidth(200)
# self.userTextbox.setFixedHeight(28)
# Feature Recommendations
recTopOffset = 500
self.textboxLabel = QLabel("Feature Recommendations", self.widget)
self.textboxLabel.move(30, recTopOffset)
self.textboxLabel.show()
self.recListFeature = QListWidget(self.widget)
self.recListFeature.move(30, recTopOffset + 30)
self.recListFeature.resize(280, 250)
self.recListFeature.show()
# Item-based Recommendations
self.textboxLabel = QLabel("Item-based Recommendations", self.widget)
self.textboxLabel.move(340, recTopOffset)
self.textboxLabel.show
self.recListItem = QListWidget(self.widget)
self.recListItem.move(340, recTopOffset + 30)
self.recListItem.resize(280, 250)
self.recListItem.show()
# User-based Recommendations
self.textboxLabel = QLabel("User-based Recommendations", self.widget)
self.textboxLabel.move(650, recTopOffset)
self.textboxLabel.show
self.recListUser = QListWidget(self.widget)
self.recListUser.move(650, recTopOffset + 30)
self.recListUser.resize(280, 250)
self.recListUser.show()
# Categories
categoryTopOffset = 300
self.textboxLabel = QLabel("Categories", self.widget)
self.textboxLabel.move(30, recTopOffset + categoryTopOffset)
self.textboxLabel.show
button1 = QPushButton("By Agency", self.widget)
button1.clicked.connect(lambda: self.listCategory_clicked("agency"))
button1.move(30, recTopOffset + categoryTopOffset + 30)
button1.show()
button2 = QPushButton("By Instrument", self.widget)
button2.clicked.connect(lambda: self.listCategory_clicked("instrument"))
button2.move(margin + button1.width() + 20, recTopOffset + categoryTopOffset + 30)
button2.show()
button3 = QPushButton("By Data Source Input", self.widget)
button3.clicked.connect(lambda: self.listCategory_clicked("input"))
button3.move(margin + button1.width() + button2.width() + 40, recTopOffset + categoryTopOffset + 30)
button3.show()
# Show and move widget
self.widget.move(QtGui.QApplication.desktop().screen().rect().center() - \
self.widget.rect().center())
self.widget.show()
# Service and workflow recommendation
self.add_btn = QPushButton("Add to Palette", self.widget)
self.add_btn.clicked.connect(self.add_new_api)
self.add_btn.hide()
self.add_btn.setFixedWidth(160)
self.add_btn.move(470, 20)
self.recommendLabel = QLabel("Also Used", self.widget)
self.recommendLabel.hide()
self.recommendLabel.setFixedWidth(160)
self.recommendLabel.move(470, 50)
self.switch_btn_apis = QPushButton("Related Workflows", self.widget)
self.switch_btn_apis.clicked.connect(self._show_related_apis)
self.switch_btn_apis.hide()
self.switch_btn_apis.setFixedWidth(160)
self.switch_btn_apis.move(470, 80)
self.switch_btn_mashups = QPushButton("Related Modules", self.widget)
self.switch_btn_mashups.clicked.connect(self._show_related_mashups)
self.switch_btn_mashups.hide()
self.switch_btn_mashups.setFixedWidth(160)
self.switch_btn_mashups.move(470, 80)
def printMessage(self):
print "testing"
def __init__(self, parent=None):
self.data_source = DataSource()
def getRecommendations(self, url, listWidget):
# http GET request
username = str(self.userTextbox.toPlainText())
url = url + "?username=kzhang&top_num=5" # + username
print url
results = json.load(urllib2.urlopen(url))
# Update recommendation list
listWidget.clear()
for result in results:
dataset = self.climateData[int(result["datasetID"])]
item = QListWidgetItem(dataset["name"])
item.setData(Qt.UserRole, dataset)
listWidget.addItem(item)
listWidget.clicked.connect(lambda: self.dataset_clicked(\
listWidget.currentItem().data(Qt.UserRole)))
def listCategory_clicked(self, category):
self.categoryWindow = QWidget()
c = self.categoryWindow
c.setWindowTitle("Search dataset by category")
c.setMinimumSize(600, 500)
# Category list showing all posible options
label1 = QLabel("Options by {0}:".format(category), c)
label1.move(50, 20)
label1.show()
categoryListWidget = QListWidget(c)
optionSet = set()
for key in self.climateData:
optionSet.add(self.climateData[key][category])
for option in sorted(list(optionSet)):
item = QListWidgetItem(option)
item.setData(Qt.UserRole, option)
categoryListWidget.addItem(item)
categoryListWidget.move(50, 50)
categoryListWidget.resize(200, 400)
categoryListWidget.show()
categoryListWidget.clicked.connect(lambda: self.categoryItem_clicked(\
category, categoryListWidget.currentItem().data(Qt.UserRole)))
# List showing all datasets associated with the selected option
label2 = QLabel("Available Datasets:", c)
label2.move(250, 20)
label2.show()
self.datasetListWidget = QListWidget(c)
self.datasetListWidget.move(250, 50)
self.datasetListWidget.resize(400, 400)
self.datasetListWidget.show()
c.move(QtGui.QApplication.desktop().screen().rect().center() - \
c.rect().center())
c.show()
def categoryItem_clicked(self, category, option):
self.datasetListWidget.clear()
results = []
for key in self.climateData:
if self.climateData[key][category] == option:
results.append(self.climateData[key])
for result in sorted(results):
item = QListWidgetItem(result["name"])
item.setData(Qt.UserRole,result)
self.datasetListWidget.addItem(item)
self.datasetListWidget.clicked.connect(lambda: self.dataset_clicked(\
self.datasetListWidget.currentItem().data(Qt.UserRole)));
def dataset_clicked(self, data):
# Initiate Table
keyOrder = ["name", "agency", "instrument", "pvar", "var", "units", "grid", \
"webvar", "input", "start", "end"]
sortedData = sorted(data.items(), key=lambda dataPair:keyOrder.index(dataPair[0]))
self.topServiceTable = QTableWidget()
t = self.topServiceTable
t.setWindowTitle(data["name"])
t.resize(550, 400)
t.setRowCount(len(data.keys()))
t.setColumnCount(2)
t.setColumnWidth(0, 100);
t.setColumnWidth(1, 400);
# Set label
t.setHorizontalHeaderLabels(("Variable;Value").split(";"))
# Set data
for row, pair in enumerate(sortedData):
t.setItem(row, 0, QTableWidgetItem(pair[0]))
t.setItem(row, 1, QTableWidgetItem(pair[1]))
t.move(QtGui.QApplication.desktop().screen().rect().topRight() - t.rect().topRight())
t.show()
def table_clicked(self):
"""
Click the table, the graph form may change according to the selection.
"""
model = self.table.selectionModel()
indexes = model.selectedIndexes()
for index in indexes:
row = index.row()
# data = index.model().headerData(0,Qt.Horizontal).toString()
data = index.model().headerData(0,Qt.Horizontal)
newIndex = index.model().index(row, 0)
if data == "API":
api_id = get_api_full_name(newIndex.model().data(newIndex))
api = self.data_source.api_by_id(api_id)
print api
mashups = self.data_source.mashups_by_api(api)
apis = []
for mashup in mashups:
apis.extend(self.data_source.apis_by_mashup(mashup))
self.graph_form.draw_apis(apis, api, self.highlighted_api)
else:
mashup_id = get_mashup_full_name(newIndex.model().data(newIndex))
mashup = self.data_source.mashup_by_id(mashup_id)
if not mashup:
return
apis = self.data_source.apis_by_mashup(mashup)
mashups = []
if len(apis) > 0:
mashups.extend(self.data_source.mashups_by_api(apis[0]))
self.graph_form.draw_mashups(mashups, mashup, self.highlighted_mashup)
return
def _show_apis(self, apis, recommend=False):
self.switch_btn_apis.hide()
self.switch_btn_mashups.hide()
self.recommendLabel.hide()
row = 0
model = QStandardItemModel(len(apis), 4)
model.setColumnCount(4)
#QVariant(...) -> ...
for api in apis:
model.setData(model.index(row, 0), get_api_name(api))
model.setData(model.index(row, 1), api['protocols'])
model.setData(model.index(row, 2), api['provider'])
model.setData(model.index(row, 3), api['version'])
row += 1
model.setHeaderData(0, Qt.Horizontal, "Service") # Replaced "Module" with "Service"
model.setHeaderData(1, Qt.Horizontal, "Protocol")
model.setHeaderData(2, Qt.Horizontal, "Provider")
model.setHeaderData(3, Qt.Horizontal, "Version")
self.table.setModel(model)
self.table.resizeColumnsToContents()
if recommend:
self.recommendLabel.show()
self.add_btn.show()
def _show_mashups(self, mashups):
self.switch_btn_apis.hide()
self.switch_btn_mashups.hide()
self.recommendLabel.hide()
row = 0
model = QStandardItemModel(len(mashups), 4)
model.setColumnCount(4)
for mashup in mashups:
model.setData(model.index(row, 0), get_mashup_name(mashup))
model.setData(model.index(row, 1), mashup['title'])
model.setData(model.index(row, 2), mashup['self'])
model.setData(model.index(row, 3), mashup['description'])
row += 1
model.setHeaderData(0, Qt.Horizontal, "Workflow")
model.setHeaderData(1, Qt.Horizontal, "Short Description")
model.setHeaderData(2, Qt.Horizontal, "Provider")
model.setHeaderData(3, Qt.Horizontal, "Detailed Info")
self.table.setModel(model)
self.table.resizeColumnsToContents()
self.add_btn.show()
def api_button_clicked(self):
"""
Trigger to search APIs
"""
self.graph_form.draw_api()
self.graph_form.show()
# Get user input from textbox
apis = self.data_source.apis()
key = str(self.textbox.toPlainText())
if key:
self.api_search_button_clicked()
else:
self._show_apis(apis)
def mashups_button_clicked(self):
"""
Trigger to search mashups
"""
self.graph_form.draw_mashup()
self.graph_form.show()
key = str(self.textbox.toPlainText())
print key
print "button clicked"
if key:
self.mashup_search_button_clicked()
else:
self._show_mashups(self.data_source.mashups())
#Should probably refactor this into one method.
def api_search_button_clicked(self):
"""
Search when keyword is present
"""
self.highlighted_api = None
self.highlighted_mashup = None
key = str(self.textbox.toPlainText())
if key != "":
apis = self.data_source.search_api(key)
self._show_apis(apis)
def mashup_search_button_clicked(self):
"""
Search when keyword is present
"""
self.highlighted_api = None
self.highlighted_mashup = None
key = str(self.textbox.toPlainText())
if key != "":
mashups = self.data_source.search_mashup(key)
self._show_mashups(mashups)
def add_new_api(self):
"""
Add new api to the modules package.
"""
apis = self.data_source.apis()
model = self.table.selectionModel()
indexes = model.selectedIndexes()
for index in indexes:
api = apis[index.row()]
self._add_new_api(api)
return
def add_related_api(self):
objs = []
for mashup in self.related_mashups:
objs.append(mashup)
for api in mashup["related_mashups"]:
objs.append(api)
model = self.table.selectionModel()
indexes = model.selectedIndexes()
for index in indexes:
api = objs[index.row()]
if api.get("protocols"):
self._add_new_api(api)
return
def _show_related_mashups(self):
self.switch_btn_apis.hide()
self.switch_btn_mashups.hide()
self.recommendLabel.hide()
apis = []
objs = []
for mashup in self.related_mashups:
apis.extend(mashup["related_mashups"])
for api in apis:
objs.append(api)
mashups = self.data_source.mashups_by_api(api)
objs.extend(mashups)
row = 0
model = QStandardItemModel(len(objs), 4)
model.setColumnCount(4)
for obj in objs:
if obj.get('protocols'):
model.setData(model.index(row, 0), get_api_name(obj))
model.setData(model.index(row, 1), obj['protocols'])
model.setData(model.index(row, 2), obj['provider'])
else:
model.setData(model.index(row, 3), get_mashup_name(obj))
row += 1
model.setHeaderData(0, Qt.Horizontal, "API")
model.setHeaderData(1, Qt.Horizontal, "Protocols")
model.setHeaderData(2, Qt.Horizontal, "Provider")
model.setHeaderData(3, Qt.Horizontal, "Mashup")
self.table.setModel(model)
self.table.resizeColumnsToContents()
self.switch_btn_apis.show()
def _show_related_apis(self):
self.switch_btn_apis.hide()
self.switch_btn_mashups.hide()
self.recommendLabel.hide()
row = 0
objs = []
for mashup in self.related_mashups:
objs.append(mashup)
for api in mashup["related_mashups"]:
objs.append(api)
#Combining similarity and related.
similar_apis = self.data_source.search_api_similarity(self.highlighted_api)
#return str(mashup['id'])[(len("http://www.programmableweb.com/mashup/")):]
objs.append({'id': "http://www.programmableweb.com/mashup/Using-Similarity-Metric"})
objs.extend(similar_apis)
#Combining similarity and related.
#http://localhost:9000/getReputation/John%20Lions
model = QStandardItemModel(len(objs), 6)
for obj in objs:
if obj.get('protocols'):
model.setData(model.index(row, 1), get_api_name(obj))
model.setData(model.index(row, 2), obj['protocols'])
model.setData(model.index(row, 3), obj['provider'])
model.setData(model.index(row, 4), obj['version'])
#trust = requests.get('http://localhost:9000/getReputation/Luis Ramos').content
model.setData(model.index(row, 5), str(random.random()))
#model.setData(model.index(row, 5), QVariant(trust))
else:
model.setData(model.index(row, 0), get_mashup_name(obj))
row += 1
model.setHeaderData(0, Qt.Horizontal, "Mashup")
model.setHeaderData(1, Qt.Horizontal, "API")
model.setHeaderData(2, Qt.Horizontal, "Protocols")
model.setHeaderData(3, Qt.Horizontal, "Provider")
model.setHeaderData(4, Qt.Horizontal, "Version")
model.setHeaderData(5, Qt.Horizontal, "Trust")
self.table.setModel(model)
self.table.resizeColumnsToContents()
self.switch_btn_mashups.show()
def _add_new_api(self, api):
self.highlighted_api = api
mashups = self.data_source.mashups_by_api(api)
for mashup in mashups:
mashup['related_mashups'] = (self.data_source.apis_by_mashup(mashup))
if len(mashups) > 0:
self.related_mashups = mashups
self._show_related_apis()
manager = core.packagemanager.get_package_manager()
reg = core.modules.module_registry.get_module_registry()
package = manager.get_package("edu.cmu.sv.components", "1.0.0")
core.modules.module_registry.set_current_package(package)
if (api["protocols"] == "SOAP" and api["wsdl"] != ""):
s = Service(api["wsdl"])
# add_new_service(s, api["wsdl"])
else:
new_module = vistrails_module.new_module(Module, get_api_name(api))
reg.add_module(new_module)
reg.add_input_port(new_module, "value1",
(core.modules.basic_modules.String, 'the first argument'))
reg.add_input_port(new_module, "value2",
(core.modules.basic_modules.String, 'the second argument'))
reg.add_output_port(new_module, "value",
(core.modules.basic_modules.String, 'the result'))
# def loadClimateDataSet(self):
# filename = '/home/hywel/Documents/VisTrailsRecommendation/vistrails_current/vistrails/packages/componentSearch/Climate_Datasets.csv'
# with open(filename, mode='r') as infile:
# reader = csv.reader(infile)
# next(reader, None)
# with open('coors_new.csv', mode='w') as outfile:
# writer = csv.writer(outfile)
# climateData = {}
# for row in reader:
# id = int(row[0])
# climateData[id] = {}
# climateData[id]["dataset"] = row[1]
# climateData[id]["agency"] = row[2]
# climateData[id]["instrument"] = row[3]
# climateData[id]["pvar"] = row[4]
# climateData[id]["var"] = row[5]
# climateData[id]["units"] = row[6]
# climateData[id]["grid"] = row[7]
# climateData[id]["webvar"] = row[8]
# climateData[id]["input"] = row[9]
# climateData[id]["start"] = row[10]
# climateData[id]["end"] = row[11]
# return climateData
def parseServerData(self, data):
climateData = {}
for dataset in data:
id = int(dataset["datasetID"])
climateData[id] = {}
climateData[id]["name"] = dataset["dataset"]
climateData[id]["agency"] = dataset["agency"]
climateData[id]["instrument"] = dataset["instrument"]
climateData[id]["pvar"] = dataset["pvar"]
climateData[id]["var"] = dataset["var"]
climateData[id]["units"] = dataset["units"]
climateData[id]["grid"] = dataset["grid"]
climateData[id]["webvar"] = dataset["webvar"]
climateData[id]["input"] = dataset["input"]
climateData[id]["start"] = dataset["start"]
climateData[id]["end"] = dataset["end"]
return climateData
