def createWidgets(self):
"""
Create qt widgets
"""
self.proxyModel = QSortFilterProxyModel(self)
self.proxyModel.setDynamicSortFilter(True)
self.model = DescriptionTableModel(self)
self.setModel(self.proxyModel)
self.proxyModel.setSourceModel(self.model)
self.setFrameShape(QFrame.StyledPanel)
self.setShowGrid(True)
self.setGridStyle(Qt.DotLine)
self.setSelectionMode(QAbstractItemView.SingleSelection)
self.setSelectionBehavior(QAbstractItemView.SelectRows)
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.verticalHeader().setVisible(False)
self.horizontalHeader().setHighlightSections(False)
self.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel)
self.horizontalHeader().setStretchLastSection(True)
self.setItemDelegateForColumn(COL_SUMMARY_ACTION,
AdapterDelegate(self))
self.setColumnWidth(COL_ID_ACTION, 45)
def set_model_by_list(self, string_list, widget):
model = QStringListModel()
model.setStringList(string_list)
self.proxy_model = QSortFilterProxyModel()
self.proxy_model.setSourceModel(model)
self.proxy_model.setFilterKeyColumn(0)
proxy_model_aux = QSortFilterProxyModel()
proxy_model_aux.setSourceModel(model)
proxy_model_aux.setFilterKeyColumn(0)
widget.setModel(proxy_model_aux)
widget.setModelColumn(0)
completer = QCompleter()
completer.setModel(self.proxy_model)
completer.setCompletionColumn(0)
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
widget.setCompleter(completer)
def init_proxy_model(self, name, column):
proxy = QSortFilterProxyModel()
proxy.setSourceModel(self.model)
proxy.setFilterKeyColumn(column)
proxy.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.model = proxy
self.sortProxyModels[name] = proxy
return proxy
def __init__(self, showTable=False, parent=None):
super(SingleSelectionSearchPanelDelegate, self).__init__(parent)
self.showTable = showTable
"""
@ivar: Si se debera o no mostrar la tabla
@type: bool
"""
self.proxymodel = QSortFilterProxyModel()
"""
def set_autocompleter(combobox, list_items=None):
""" Iterate over the items in the QCombobox, create a list,
create the model, and set the model according to the list
"""
if list_items is None:
list_items = [combobox.itemText(i) for i in range(combobox.count())]
proxy_model = QSortFilterProxyModel()
set_model_by_list(list_items, combobox, proxy_model)
combobox.editTextChanged.connect(
partial(filter_by_list, combobox, proxy_model))
def __init__(self, parent=None, **kwargs):
super(AddonManagerWidget, self).__init__(parent, **kwargs)
self.setLayout(QVBoxLayout())
self.__header = QLabel(
wordWrap=True,
textFormat=Qt.RichText
)
self.__search = QLineEdit(
placeholderText=self.tr("Filter")
)
self.layout().addWidget(self.__search)
self.__view = view = QTreeView(
rootIsDecorated=False,
editTriggers=QTreeView.NoEditTriggers,
selectionMode=QTreeView.SingleSelection,
alternatingRowColors=True
)
self.__view.setItemDelegateForColumn(0, TristateCheckItemDelegate())
self.layout().addWidget(view)
self.__model = model = QStandardItemModel()
model.setHorizontalHeaderLabels(["", "Name", "Version", "Action"])
model.dataChanged.connect(self.__data_changed)
proxy = QSortFilterProxyModel(
filterKeyColumn=1,
filterCaseSensitivity=Qt.CaseInsensitive
)
proxy.setSourceModel(model)
self.__search.textChanged.connect(proxy.setFilterFixedString)
view.setModel(proxy)
view.selectionModel().selectionChanged.connect(
self.__update_details
)
header = self.__view.header()
header.setResizeMode(0, QHeaderView.Fixed)
header.setResizeMode(2, QHeaderView.ResizeToContents)
self.__details = QTextBrowser(
frameShape=QTextBrowser.NoFrame,
readOnly=True,
lineWrapMode=QTextBrowser.WidgetWidth,
openExternalLinks=True,
)
self.__details.setWordWrapMode(QTextOption.WordWrap)
palette = QPalette(self.palette())
palette.setColor(QPalette.Base, Qt.transparent)
self.__details.setPalette(palette)
self.layout().addWidget(self.__details)
def initListView(self):
self.ListView = ListView(self, self.__mainWindow)
self.ListModel = ListModel(self)
self.ListModelFilter = QSortFilterProxyModel()
self.ListModelFilter.setDynamicSortFilter(True)
self.ListModelFilter.setSortCaseSensitivity(Qt.CaseInsensitive)
self.ListModelFilter.setSourceModel(self.ListModel)
self.ListView.setModels(self.ListModel, self.ListModelFilter)
self.ListView.setModel(self.ListModelFilter)
self.ListView.setSubMenu(self.submenuFile)
self.vlayout.addWidget(self.ListView)
def __init__(self, parent=None):
super(CompletingComboBox, self).__init__(parent)
self.setEditable(True)
self.filter = QSortFilterProxyModel(self)
self.filter.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.filter.setSourceModel(self.model())
self.completer = QCompleter(self.filter, self)
self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.setCompleter(self.completer)
self.lineEdit().textEdited[unicode]\
.connect(self.filter.setFilterFixedString)
self.currentIndexChanged.connect(self._index_changed)
self.setAutoCompletion(True)
def setup_mapper(self):
"""
Create the data widget mapper and set a proxy on the model
"""
self.mapper = QDataWidgetMapper()
self.proxy = QSortFilterProxyModel()
self.proxy.setSourceModel(self.model)
self.proxy.setDynamicSortFilter(True)
self.mapper.setModel(self.proxy)
self.mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
# Set custom delegate for mapping to date widgets
self.mapper.setItemDelegate(DateMapperCustomDelegate(self.date_cols))
self.map_widgets(self.mapper)
def setup_proxy_and_mapper(self):
"""
Map data fields to widgets in street browser and create proxy for filtering
"""
self.mapper = QDataWidgetMapper()
self.proxy = QSortFilterProxyModel()
self.proxy.setSourceModel(self.model)
self.proxy.setDynamicSortFilter(True)
self.mapper.setModel(self.proxy)
self.mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
# Set custom delegate for mapping to date widgets
self.mapper.setItemDelegate(DateMapperCustomDelegate([6, 7, 8, 18]))
self.mapper.currentIndexChanged.connect(self.mapper_idx_changed)
self.map_widgets(self.mapper)
def __init__(self, parent=None):
super(BigList, self).__init__(parent)
self.setupUi(self)
self.listView.clicked.connect(self.selected)
self.saveButton.pressed.connect(self.savewidget.emit)
self.closebutton.pressed.connect(self.closewidget.emit)
self._index = None
self.search.textEdited.connect(self.set_filter)
self.filtermodel = QSortFilterProxyModel()
self.filtermodel.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.listView.setModel(self.filtermodel)
self.charm = FlickCharm()
self.charm.activateOn(self.listView)
def __init__(self, parent=None):
super(ExtendedComboBox, self).__init__(parent)
self.setFocusPolicy(Qt.StrongFocus)
self.setEditable(True)
self.pFilterModel = QSortFilterProxyModel(self)
self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.pFilterModel.setSourceModel(self.model())
self.completer = QCompleter(self.pFilterModel, self)
self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.completer.popup().setStyleSheet('min-height: 150px')
self.completer.popup().setAlternatingRowColors(True)
self.setCompleter(self.completer)
self.lineEdit().textEdited[unicode].connect(self.pFilterModel.setFilterFixedString)
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
uic.loadUi("mainwindow.ui", self)
strlist = QStringList()
strlist.append("yafei")
strlist.append("yafeilinux")
strlist.append("Qt")
strlist.append("Qt Creator")
listModel = QStringListModel(strlist, self)
self.filterModel = QSortFilterProxyModel(self)
# 为代理模型添加源模型
self.filterModel.setSourceModel(listModel)
# 在视图中使用代理模型
self.listView.setModel(self.filterModel)
def __init__( self ,tipopersona, parent ):
'''
Constructor
'''
super( dlgPersona, self ).__init__( parent )
self.setupUi(self)
# self.tableview.addActions( ( self.actionEdit, self.actionNew ) )
self.idtipopersona = tipopersona
self.table = ""
self.backmodel = QSqlQueryModel()
self.database = parent.database
self.filtermodel = QSortFilterProxyModel( self )
self.filtermodel.setSourceModel( self.backmodel )
self.filtermodel.setDynamicSortFilter( True )
self.filtermodel.setFilterKeyColumn( -1 )
self.filtermodel.setFilterCaseSensitivity( Qt.CaseInsensitive )
self.paisesModel = QSqlQueryModel()
self.cbpais.setModel( self.paisesModel )
self.cbpais.setCurrentIndex( -1 )
self.cbpais.setFocus()
self.cbpais.setModelColumn( 1 )
self.paisescompleter = QCompleter()
self.paisescompleter.setCaseSensitivity( Qt.CaseInsensitive )
self.paisescompleter.setModel( self.paisesModel )
self.paisescompleter.setCompletionColumn( 1 )
self.cbpais.setCompleter( self.paisescompleter )
self.proveedoresModel = QSqlQueryModel()
self.cbproveedor.setModel( self.proveedoresModel )
self.cbproveedor.setCurrentIndex( -1 )
self.cbproveedor.setFocus()
self.cbproveedor.setModelColumn( 1 )
self.proveedorcompleter = QCompleter()
self.proveedorcompleter.setCaseSensitivity( Qt.CaseInsensitive )
self.proveedorcompleter.setModel( self.proveedoresModel )
self.proveedorcompleter.setCompletionColumn( 1 )
self.cbproveedor.setCompleter( self.proveedorcompleter )
# self.tableview.setModel(self.filtermodel)
self.cbsexo.setCurrentIndex(-1)
self.txtnombre.setFocus()
self.setReadOnly(True)
QTimer.singleShot( 0, self.updateModels )
def setModel(self, model):
" Sets the watch expression model "
self.__model = model
self.sortingModel = QSortFilterProxyModel()
self.sortingModel.setSourceModel(self.__model)
QTreeView.setModel(self, self.sortingModel)
header = self.header()
header.setSortIndicator(0, Qt.AscendingOrder)
header.setSortIndicatorShown(True)
header.setClickable(True)
self.setSortingEnabled(True)
self.__layoutDisplay()
return
def set_sb_mapper_idx(self, usrn):
"""
Use a proxy to find the mapper idx for the usrn
:param usrn: USRN
"""
model = self.mapper.model()
# Create proxy
search_proxy = QSortFilterProxyModel()
search_proxy.setSourceModel(model)
search_proxy.setDynamicSortFilter(True)
search_proxy.setFilterKeyColumn(1) # usrn col
search_proxy.setFilterFixedString(str(usrn))
# Assume only 1 record is in the filtered proxy
source_idx = search_proxy.mapToSource(search_proxy.index(0, 0))
source_row = source_idx.row()
self.mapper.setCurrentIndex(source_row)
def set_model_by_list(string_list, widget, proxy_model):
""" Set the model according to the list """
model = QStringListModel()
model.setStringList(string_list)
proxy_model.setSourceModel(model)
proxy_model.setFilterKeyColumn(0)
proxy_model_aux = QSortFilterProxyModel()
proxy_model_aux.setSourceModel(model)
proxy_model_aux.setFilterKeyColumn(0)
widget.setModel(proxy_model_aux)
widget.setModelColumn(0)
completer = QCompleter()
completer.setModel(proxy_model)
completer.setCompletionColumn(0)
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
widget.setCompleter(completer)
def __init__(self):
self.data = None
self.classifier = None
self.selected = None
self.model = CustomRuleViewerTableModel(parent=self)
self.model.set_horizontal_header_labels([
"IF conditions", "", "THEN class", "Distribution",
"Probabilities [%]", "Quality", "Length"
])
self.proxy_model = QSortFilterProxyModel(parent=self)
self.proxy_model.setSourceModel(self.model)
self.proxy_model.setSortRole(self.model.SortRole)
self.view = gui.TableView(self, wordWrap=False)
self.view.setModel(self.proxy_model)
self.view.verticalHeader().setVisible(True)
self.view.horizontalHeader().setStretchLastSection(False)
self.view.selectionModel().selectionChanged.connect(self.commit)
self.dist_item_delegate = DistributionItemDelegate(self)
self.view.setItemDelegateForColumn(3, self.dist_item_delegate)
self.mainArea.layout().setContentsMargins(0, 0, 0, 0)
self.mainArea.layout().addWidget(self.view)
bottom_box = gui.hBox(widget=self.mainArea,
box=None,
margin=0,
spacing=0)
original_order_button = QPushButton("Restore original order",
autoDefault=False)
original_order_button.setFixedWidth(180)
bottom_box.layout().addWidget(original_order_button)
original_order_button.clicked.connect(self.restore_original_order)
gui.separator(bottom_box, width=5, height=0)
gui.checkBox(widget=bottom_box,
master=self,
value="compact_view",
label="Compact view",
callback=self.on_update)
self.report_button.setFixedWidth(180)
bottom_box.layout().addWidget(self.report_button)
def createWidgets(self):
"""
"""
self.proxyModel = QSortFilterProxyModel(self)
self.proxyModel.setDynamicSortFilter(True)
self.model = CacheTableModel(self)
self.setModel(self.proxyModel)
self.proxyModel.setSourceModel(self.model)
self.setShowGrid(True)
self.setGridStyle(Qt.DotLine)
self.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.setSelectionBehavior(QAbstractItemView.SelectRows)
self.horizontalHeader().setStretchLastSection(True)
def get_matched_row_list(self, key_column, search_criteria,
case_sensitivity):
search_proxy = QSortFilterProxyModel()
search_proxy.setSourceModel(self.user_interface.tblLogData.model())
search_proxy.setFilterCaseSensitivity(case_sensitivity)
search_proxy.setFilterKeyColumn(key_column)
if self.is_match_whole_word:
search_criteria = r"\b{}\b".format(search_criteria)
search_proxy.setFilterRegExp(search_criteria)
matched_row_list = []
for proxy_row in range(search_proxy.rowCount()):
match_index = search_proxy.mapToSource(
search_proxy.index(proxy_row, key_column))
matched_row_list.append(match_index.row())
self.search_criteria_updated = False
return matched_row_list
def __init__(self, parent=None):
super(ExtendedComboBox, self).__init__(parent)
self.setFocusPolicy(Qt.StrongFocus)
self.setEditable(True)
self.setCurrentIndex(-1)
# self.activated.connect(self.on_completer_activated)
# add a filter model to filter matching items
self.pFilterModel = QSortFilterProxyModel(self)
self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.pFilterModel.setSourceModel(self.model())
# add a completer, which uses the filter model
self.completer = QCompleter(self.pFilterModel, self)
# always show all (filtered) completions
self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.setCompleter(self.completer)
def __init__( self, parent = None):
super( ExtendedCombo, self ).__init__( parent )
self.setFocusPolicy( Qt.StrongFocus )
self.setEditable( True )
self.completer = QCompleter( self )
# always show all completions
self.completer.setCompletionMode( QCompleter.UnfilteredPopupCompletion )
self.pFilterModel = QSortFilterProxyModel( self )
self.pFilterModel.setFilterCaseSensitivity( Qt.CaseInsensitive )
self.completer.setPopup( self.view() )
self.setCompleter( self.completer )
self.lineEdit().textEdited[unicode].connect( self.pFilterModel.setFilterFixedString )
self.completer.activated.connect(self.setTextIfCompleterIsClicked)
def _onItemsCompleted(self):
self.setBlocking(False)
self.progressBarFinished()
self.setEnabled(True)
try:
schema, geneinfo = self.itemsfuture.result()
finally:
self.itemsfuture = None
self.geneinfo = geneinfo = list(zip(self.genes, geneinfo))
self.cells = cells = []
self.row2geneinfo = {}
links = []
for i, (_, gi) in enumerate(geneinfo):
if gi:
row = []
for _, item in zip(schema, gi):
if isinstance(item, Link):
# TODO: This should be handled by delegates
row.append(item.text)
links.append(item.link)
else:
row.append(item)
cells.append(row)
self.row2geneinfo[len(cells) - 1] = i
model = TreeModel(cells, [str(col) for col in schema], None)
model.setColumnLinks(0, links)
proxyModel = QSortFilterProxyModel(self)
proxyModel.setSourceModel(model)
self.treeWidget.setModel(proxyModel)
self.treeWidget.selectionModel().selectionChanged.connect(self.commit)
for i in range(7):
self.treeWidget.resizeColumnToContents(i)
self.treeWidget.setColumnWidth(
i, min(self.treeWidget.columnWidth(i), 200)
)
self.infoLabel.setText("%i genes\n%i matched NCBI's IDs" %
(len(self.genes), len(cells)))
self.matchedInfo = len(self.genes), len(cells)
def __init__(self, parent=None):
super(DsgCustomComboBox, self).__init__(parent)
self.setFocusPolicy(Qt.StrongFocus)
self.setEditable(True)
# add a filter model to filter matching items
self.pFilterModel = QSortFilterProxyModel(self)
self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.pFilterModel.setSourceModel(self.model())
# add a completer, which uses the filter model
self.completer = QCompleter(self.pFilterModel, self)
# always show all (filtered) completions
self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.setCompleter(self.completer)
# connect signals
self.lineEdit().textEdited[unicode].connect(self.pFilterModel.setFilterFixedString)
self.completer.activated.connect(self.on_completer_activated)
def load_presentations_model(self):
# Load Presentation Model
self.presentationModel = self.db.get_presentations_model()
self.proxy = QSortFilterProxyModel()
self.proxy.setSourceModel(self.presentationModel)
self.tableView.setModel(self.proxy)
self.proxy.setFilterCaseSensitivity(Qt.CaseInsensitive)
# Fill table whitespace.
self.tableView.horizontalHeader().setStretchLastSection(False)
for i in range(2, self.tableView.horizontalHeader().count() + 1):
self.tableView.horizontalHeader().resizeSection(
i, self.set_width_with_dpi(80))
self.tableView.horizontalHeader().setResizeMode(1, QHeaderView.Stretch)
# Hide the ID field
self.tableView.setColumnHidden(0, True)
# Map data to widgets
self.mapper = QDataWidgetMapper()
self.mapper.setModel(self.proxy)
self.mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
self.mapper.addMapping(self.talkDetailsWidget.titleLineEdit, 1)
self.mapper.addMapping(self.talkDetailsWidget.presenterLineEdit, 2)
self.mapper.addMapping(self.talkDetailsWidget.categoryLineEdit, 4)
self.mapper.addMapping(self.talkDetailsWidget.eventLineEdit, 5)
self.mapper.addMapping(self.talkDetailsWidget.roomLineEdit, 6)
self.mapper.addMapping(self.talkDetailsWidget.descriptionTextEdit, 3)
self.mapper.addMapping(self.talkDetailsWidget.dateEdit, 7)
self.mapper.addMapping(self.talkDetailsWidget.startTimeEdit, 8)
self.mapper.addMapping(self.talkDetailsWidget.endTimeEdit, 9)
# Load StringLists
self.titleList = QStringList(self.db.get_string_list("Title"))
#self.speakerList = QStringList(self.db.get_speaker_list())
#self.categoryList = QStringList(self.db.get_category_list())
#self.eventList = QStringList(self.db.get_event_list())
#self.roomList = QStringList(self.db.get_room_list())
#Disble input
self.talkDetailsWidget.disable_input_fields()
def __init__(self, parent):
'''
Constructor
'''
super(DlgPais, self).__init__(parent)
self.setupUi(self)
self.table = ""
self.backmodel = QSqlQueryModel()
self.database = parent.database
self.filtermodel = QSortFilterProxyModel(self)
self.filtermodel.setSourceModel(self.backmodel)
self.filtermodel.setDynamicSortFilter(True)
self.filtermodel.setFilterKeyColumn(-1)
self.filtermodel.setFilterCaseSensitivity(Qt.CaseInsensitive)
# self.tableview.setModel(self.filtermodel)
self.setReadOnly(True)
QTimer.singleShot(0, self.updateModels)
def __init__(self, model, parent=None, showTable=False):
super(SearchPanel, self).__init__(parent)
self.tabla = None
self.setFocusPolicy(Qt.StrongFocus)
self.setEditable(True)
# self.setModel( model )
self.setEditable(True)
self.completer = QCompleter(self)
# always show all completions
self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.pFilterModel = QSortFilterProxyModel(self)
self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.showTable = showTable
if model != None:
self.setModel(model)
# self.pFilterModel.setSourceModel( model );
self.completer.setModel(self.pFilterModel)
self.completerTable = SearchPanelView()
self.completer.setPopup(self.completerTable)
#Mostrar el Popup en forma de Tabla
if self.showTable:
self.tabla = SearchPanelView()
self.setView(self.tabla)
self.setCompleter(self.completer)
self.setColumn(1)
self.lineEdit().textEdited[unicode].connect(
self.pFilterModel.setFilterFixedString if not showTable else self.
pFilterModel.setFilterWildcard)
def __init__(self):
QDialog.__init__(self)
self.setupUi(self)
self.settings = MySettings()
SettingDialog.__init__(self, self.settings)
# new declaration of ProjectFinder since changes can be cancelled
self.projectFinder = ProjectFinder(self)
# table model
self.projectSearchModel = ProjectSearchModel(self.projectFinder)
self.proxyModel = QSortFilterProxyModel(self)
self.proxyModel.setSourceModel(self.projectSearchModel)
self.projectSearchTable.setModel(self.proxyModel)
header = self.projectSearchTable.horizontalHeader()
header.setResizeMode(QHeaderView.ResizeToContents)
# open/create QuickFinder file
self.createFileButton.clicked.connect(self.createQFTSfile)
self.openFileButton.clicked.connect(self.openQFTSfile)
self.readQFTSfile()
# project search
self.addSearchButton.clicked.connect(self.addProjectSearch)
self.removeSearchButton.clicked.connect(self.removeProjectSearch)
self.editSearchButton.clicked.connect(self.editProjectSearch)
self.refreshButton.clicked.connect(self.refreshProjectSearch)
self.projectSearchTable.selectionModel().selectionChanged.connect(
self.enableButtons)
self.enableButtons()
# geomapfish
self.geomapfishCrsButton.clicked.connect(
self.geomapfishCrsButtonClicked)
def __init__(self, parent=None, aptinkerQSettings=None):
"""Constructor"""
QDialog.__init__(self, parent=parent)
self.setupUi(self)
self.setWindowFlags(Qt.Window) # To add Maximize & Minimize buttons
self.setWindowTitle('Select Snapshot from Database')
# Load Startup Preferences for Snapshot Table
self.default_ss_pref = dict(
vis_col_key_list=config.DEF_VIS_COL_KEYS['snapshot_DB'][:])
if osp.exists(PREF_SS_JSON_FILEPATH):
with open(PREF_SS_JSON_FILEPATH, 'r') as f:
self.ss_pref = json.load(f)
else:
self.ss_pref = self.default_ss_pref
# Load Startup Preferences for Snapshot Meta Table
self.default_ss_meta_pref = dict(vis_col_key_list=[
'ss_id', 'config_id', 'ss_ctime', 'ss_name', 'ss_username'
])
if osp.exists(PREF_SS_META_JSON_FILEPATH):
with open(PREF_SS_META_JSON_FILEPATH, 'r') as f:
self.ss_meta_pref = json.load(f)
else:
self.ss_meta_pref = self.default_ss_meta_pref
self.ssDBViewWidget = SnapshotDBViewWidget(self.groupBox_selected_ss,
DB_selector=True)
self.tableView_ss = self.ssDBViewWidget.tableView
self.ssMetaDBViewWidget = SnapshotMetaDBViewWidget(
self.groupBox_search_result)
self.tableView_ss_meta = self.ssMetaDBViewWidget.tableView
self.textEdit_description = \
self.ssMetaDBViewWidget.textEdit_description
self.settings = QSettings('APHLA', 'TinkerSSDBSelector')
self.loadViewSettings()
self._aptinkerQSettings = aptinkerQSettings
self.pushButton_search.setIcon(QIcon(':/search.png'))
all_ctime_operators = [
self.comboBox_time_created_1.itemText(i)
for i in range(self.comboBox_time_created_1.count())
]
self.comboBox_time_created_1.setCurrentIndex(
all_ctime_operators.index(''))
self.dateTimeEdit_time_created_1.setDateTime(
QDateTime.currentDateTime())
self.dateTimeEdit_time_created_2.setDateTime(
QDateTime.currentDateTime())
self.search_params = dict(ss_id_1='',
ss_id_2='',
config_id_1='',
config_id_2='',
ss_ref_step_size_1='',
ss_ref_step_size_2='',
ss_name='',
ss_desc='',
ss_username='',
ss_ctime_1='',
ss_ctime_2='',
ss_synced_gruop_weight='',
ss_masar_id_1='',
ss_masar_id_2='')
db_id_validator = QIntValidator()
db_id_validator.setBottom(1)
self.lineEdit_ss_id_1.setValidator(db_id_validator)
self.lineEdit_ss_id_2.setValidator(db_id_validator)
self.lineEdit_config_id_1.setValidator(db_id_validator)
self.lineEdit_config_id_2.setValidator(db_id_validator)
self.lineEdit_masar_id_1.setValidator(db_id_validator)
self.lineEdit_masar_id_2.setValidator(db_id_validator)
self.prev_valid_ref_step_sizes = dict(lineEdit_ref_step_size_1=np.nan,
lineEdit_ref_step_size_2=np.nan)
# Set up Snapshot Table
self.ss_model = SnapshotModel(self.ss_pref['vis_col_key_list'])
self.tableModel_ss = self.ss_model.table
proxyModel = QSortFilterProxyModel()
proxyModel.setSourceModel(self.tableModel_ss)
proxyModel.setDynamicSortFilter(False)
tbV = self.tableView_ss
tbV.setModel(proxyModel)
tbV.setItemDelegate(
SnapshotDBTableViewItemDelegate(tbV, self.tableModel_ss,
tbV.parent()))
#self.db = TinkerMainDatabase()
self.db = self.ss_model.db
if '[ss_meta_table text view]' not in self.db.getViewNames(
square_brackets=True):
self.db.create_temp_ss_meta_table_text_view()
# Set up Snapshot Meta Table
self.ss_meta_all_col_keys = self.ssMetaDBViewWidget.all_col_keys
self.search_result = {k: [] for k in self.ss_meta_all_col_keys}
self.tableModel_ss_meta = MetaTableModel(self.search_result,
self.ssMetaDBViewWidget)
proxyModel = QSortFilterProxyModel()
proxyModel.setSourceModel(self.tableModel_ss_meta)
proxyModel.setDynamicSortFilter(False)
tbV = self.tableView_ss_meta
tbV.setModel(proxyModel)
self.selectionModel = QItemSelectionModel(proxyModel)
tbV.setSelectionModel(self.selectionModel)
# Apply Visible Column Preference to Snapshot Meta Table
ss_meta_vis_col_name_list = [
self.ssMetaDBViewWidget.col_names_wo_desc[
self.ssMetaDBViewWidget.col_keys_wo_desc.index(k)]
for k in self.ss_meta_pref['vis_col_key_list']
]
self.ssMetaDBViewWidget.on_column_selection_change(
ss_meta_vis_col_name_list, force_visibility_update=True)
# Make connection
self.connect(self.lineEdit_ref_step_size_1,
SIGNAL('editingFinished()'), self.validate_ref_step_size)
self.connect(self.lineEdit_ref_step_size_2,
SIGNAL('editingFinished()'), self.validate_ref_step_size)
self.connect(self.pushButton_search, SIGNAL('clicked()'),
self.update_search)
self.connect(
self.selectionModel,
SIGNAL(
'currentRowChanged(const QModelIndex &, const QModelIndex &)'),
self.on_selection_change)
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()
