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