def _build_left_dock(self):
# QTreeView for the project view
w_project_tree = QDockWidget("Project tree", self)
w_project_tree.setFloating(False)
self._docks['project tree'] = w_project_tree
self.addDockWidget(Qt.LeftDockWidgetArea, w_project_tree)
# Add the treeview
treeview = QTreeView(w_project_tree)
treedelegate = TreeDelegate()
treeview.setItemDelegate(treedelegate)
pm = ProjectModel()
self._models["project"] = pm
treeview.setModel(pm)
treeview.expandAll()
treeview.resizeColumnToContents(0)
treeview.resizeColumnToContents(1)
w_project_tree.setWidget(treeview)
treeview.clicked.connect(self.treeItemClicked)
# Formatting Editor
w_properties = QDockWidget("Properties editor", self)
w_properties.setFloating(False)
self._docks['properties'] = w_properties
self.addDockWidget(Qt.LeftDockWidgetArea, w_properties)
# Create Container widget
container = QWidget(w_properties)
# Create a verticallayout in which we put a treeview and a tableview
v_layout = QVBoxLayout(w_properties)
# Positions Properties to start with
# the treeview will contain the widgets for the properties of the selected item in the tree
treeview = QTreeView(w_properties)
v_layout.addWidget(treeview)
v_layout.setStretchFactor(treeview, 2)
treedelegate = PropertiesTreeDelegate()
treeview.setItemDelegate(treedelegate)
pm = PropertiesTreeModel()
self._models['properties'] = pm
treeview.setModel(pm)
treeview.expandAll()
# The tableview will only contain editable x,y shown as rows
tableview = QTableView(w_properties)
v_layout.addWidget(tableview)
v_layout.setStretchFactor(tableview, 1)
container.setLayout(v_layout)
w_properties.setWidget(container)
# Formatting Editor
w_formatting = QDockWidget("Formatting editor", self)
w_formatting.setFloating(False)
self._docks['formatting'] = w_formatting
self.addDockWidget(Qt.LeftDockWidgetArea, w_formatting)
def __init__(self, parent=None) -> None:
super(ProgressView, self).__init__(parent)
self._progress_tree_view = QTreeView(self)
self._progress_tree_view.setHeaderHidden(True)
self._progress_tree_view.setItemsExpandable(False)
self._progress_tree_view.setItemDelegate(ProgressDelegate(self))
self._progress_tree_view.setRootIsDecorated(False)
self._progress_tree_view.setFixedHeight(30)
self._progress_tree_view.setVerticalScrollBarPolicy(
Qt.ScrollBarAlwaysOff)
self._progress_bar = QProgressBar(self)
self._progress_bar.setRange(0, 0)
self._progress_bar.setFixedHeight(30)
self._progress_bar.setVisible(False)
layout = QVBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self._progress_tree_view)
layout.addWidget(self._progress_bar)
self.setLayout(layout)
self.setFixedHeight(30)
def __init__(self):
super().__init__()
self.gateway = QGateWay(self)
self.tree = QTreeView(self)
self.tree.setHeaderHidden(True)
# self.tree.setSelectionMode(QTreeView.MultiSelection)
self.model = OMEROTreeModel(self.gateway, self)
self.thumb_grid = ThumbGrid(self.gateway, self)
self.thumb_grid.hide()
self.login = LoginForm(self.gateway, self)
self.login.setWindowFlags(self.login.windowFlags() & ~Qt.Dialog)
self.tree.setModel(self.model)
self.tree.selectionModel().selectionChanged.connect(
self._on_tree_selection)
self.thumb_grid.itemSelectionChanged.connect(
self._on_thumbnail_selected)
layout = QVBoxLayout(self)
self.splitter = QSplitter(Qt.Vertical, self)
self.status = QLabel(self)
self.status.hide()
self.status.setAlignment(Qt.AlignCenter)
self.status.setStyleSheet("QLabel{color: #AAA;}")
layout.addWidget(self.status)
layout.addWidget(self.splitter)
self.splitter.addWidget(self.login)
self.splitter.addWidget(self.tree)
self.splitter.addWidget(self.thumb_grid)
self.gateway.connected.connect(self._show_connection_label)
def make_left_navbar(self):
"""
Creates the structures tree hierarchy widget and populates
it with structures names from the brainglobe-api's Atlas.hierarchy
tree view.
"""
# Create QTree widget
treeView = QTreeView()
treeView.setExpandsOnDoubleClick(False)
treeView.setHeaderHidden(True)
treeView.setStyleSheet(update_css(tree_css, self.palette))
treeView.setWordWrap(False)
treeModel = QStandardItemModel()
rootNode = treeModel.invisibleRootItem()
# Add element's hierarchy
tree = self.scene.atlas.hierarchy
items = {}
for n, node in enumerate(tree.expand_tree()):
# Get Node info
node = tree.get_node(node)
if node.tag in ["VS", "fiber tracts"]:
continue
# Get brainregion name
name = self.scene.atlas._get_from_structure(
node.identifier, "name"
)
# Create Item
item = StandardItem(
name,
node.tag,
tree.depth(node.identifier),
self.palette["text"],
)
# Get/assign parents
parent = tree.parent(node.identifier)
if parent is not None:
if parent.identifier not in items.keys():
continue
else:
items[parent.identifier].appendRow(item)
# Keep track of added nodes
items[node.identifier] = item
if n == 0:
root = item
# Finish up
rootNode.appendRow(root)
treeView.setModel(treeModel)
treeView.expandToDepth(2)
self.treeView = treeView
return treeView
def get_modeltree(model=None):
"""Alias to :func:`get_tree`."""
if model is None:
model = mx.cur_model()
treemodel = ModelTreeModel(model._baseattrs)
view = QTreeView()
view.setModel(treemodel)
view.setWindowTitle("Model %s" % model.name)
view.setAlternatingRowColors(True)
return view
def get_tree(model=None):
"""Get QTreeView object containing the model tree.
Args:
model: :class:`Model <modelx.core.model.Model>` object.
Defaults to the current model.
"""
if model is None:
model = mx.cur_model()
treemodel = ModelTreeModel(model._baseattrs)
view = QTreeView()
view.setModel(treemodel)
view.setWindowTitle("Model %s" % model.name)
view.setAlternatingRowColors(True)
return view
def __init__(self, model):
super(CorrelationWidget, self).__init__()
self.model = model # type: QStandardItemModel
self.resultsList = QTreeView(self)
self.resultsList.setHeaderHidden(True)
self.resultsList.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.resultsList.setSelectionMode(QAbstractItemView.NoSelection)
self.plotOpts = dict()
self._plot = pg.PlotWidget(**self.plotOpts)
self._legend = pg.LegendItem(offset=[-1, 1])
self.legend.setParentItem(self._plot.getPlotItem())
self.resultsList.setModel(self.model)
self.selectionModel = self.resultsList.selectionModel()
layout = QVBoxLayout()
layout.addWidget(self.resultsList)
layout.addWidget(self._plot)
self.setLayout(layout)
self.checkedItemIndexes = []
self._curveItems = []
def __init__(self,
name=None,
plugin=None,
parent=None,
options=DEFAULT_OPTIONS):
super().__init__(name, plugin, parent=parent, options=options)
# Widgets
self.tree = QTreeView()
self.tree.setHeaderHidden(True)
self.tree.setContextMenuPolicy(Qt.CustomContextMenu)
self.tree.customContextMenuRequested.connect(self.context_menu_manager)
# TODO: simplify the navigator to get ride of 'workspace_path'
self.project_info = ProjectNavigation('', self)
self.toolbar = ToolBar(self.project_info, self, "ATE Plugin toolbar")
# Layout
layout = QVBoxLayout()
layout.addWidget(self.tree)
self.setLayout(layout)
def create_file_system_tree_dock_widget(view_menu: QMenu) -> DockWidget:
'''
Create file system tree dock widget
Parameters
----------
view_menu : QMenu
Returns
-------
value : DockWidget
'''
widget = QTreeView()
widget.setFrameShape(QFrame.NoFrame)
m = QFileSystemModel(widget)
m.setRootPath(QDir.currentPath())
widget.setModel(m)
_State.file_system_count += 1
dock_widget = DockWidget("Filesystem {}".format(_State.file_system_count))
dock_widget.set_widget(widget)
view_menu.addAction(dock_widget.toggle_view_action())
return dock_widget
def initUI(self):
def selection_changed():
# Retrieve selected items
# selecteditems = self.tracklist.selectedItems()
selectedindexes = self.tracklist.selectedIndexes()
# Adding the selected items to the processing list
self.gpxselectedlist[:] = []
self.gpxselectednamelist[:] = []
self.selectedpalette[:] = []
for i in selectedindexes:
# print str(i.text())
self.gpxselectedlist.append(self.gpxlist[i.row()])
self.gpxselectednamelist.append(self.gpxnamelist[i.row()])
self.selectedpalette.append(self.palette[i.row()])
def ClearStats():
"""
# Some other code that could be used in the future
index = self.treemodel.indexFromItem(parent1)
self.tree.expand(index)
selmod = self.tree.selectionModel()
index2 = self.treemodel.indexFromItem(child2)
selmod.select(index2, QtCore.QItemSelectionModel.Select|QtCore.QItemSelectionModel.Rows)
root = self.treemodel.invisibleRootItem()
(item.parent() or root).removeChild(item)
"""
# Returns a list of indexes. In our case, for each row there are 2 indexes, cos there are 2 columns.
for index in self.tree.selectedIndexes():
# Consider only the first columns
if index.column() == 0:
# Need to check if it's a top item (i.e. track), otherwise if a subitem (i.e. distance or time) is selected, the result might be buggy
parent = index.parent()
parent_item = self.treemodel.itemFromIndex(parent)
if parent_item is None:
self.treemodel.removeRow(index.row())
# Application Settings
QtCore.QCoreApplication.setOrganizationName("Ste")
QtCore.QCoreApplication.setOrganizationDomain(
"https://github.com/stesalati/sport/")
QtCore.QCoreApplication.setApplicationName("TrackAnalyser")
# Config settings
self.settings = QtCore.QSettings(self)
# Proxy settings
try:
self.use_proxy = self.settings.value('use_proxy', bool)
self.proxy_config = self.settings.value('proxy_config', str)
except:
self.use_proxy = bombo.USE_PROXY
self.proxy_config = bombo.PROXY_DATA
# Actions
openfile = QAction(QtGui.QIcon("icons/openfile.png"), "Open .gpx",
self)
openfile.setShortcut("Ctrl+O")
openfile.setStatusTip("Open file")
openfile.triggered.connect(self.selectFileToOpen)
go = QAction(QtGui.QIcon("icons/go.png"), "Go!", self)
go.setShortcut("Ctrl+R")
go.setStatusTip("Run analysis")
go.triggered.connect(self.Go)
clearstats = QAction(QtGui.QIcon("icons/clear.png"), "Clear stats",
self)
clearstats.setShortcut("Ctrl+C")
clearstats.setStatusTip("Clear stats")
clearstats.triggered.connect(ClearStats)
sep1 = QAction(self)
sep1.setSeparator(True)
showpoint = QAction(QtGui.QIcon("icons/point.png"), "Show point", self)
showpoint.setShortcut("Ctrl+P")
showpoint.setStatusTip("Show point")
showpoint.triggered.connect(self.PlotSpecificAreaDialog)
sep2 = QAction(self)
sep2.setSeparator(True)
quitapp = QAction(QtGui.QIcon("icons/quit.png"), "Quit", self)
quitapp.setShortcut("Ctrl+Q")
quitapp.setStatusTip("Quit application")
quitapp.triggered.connect(qApp.quit)
configs = QAction(QtGui.QIcon("icons/configs.png"), "Configs", self)
configs.setStatusTip("Configs")
configs.triggered.connect(self.ProxyDialog)
# Menubar
mainMenu = self.menuBar()
configMenu = mainMenu.addMenu('&Config')
configMenu.addAction(configs)
# Toolbar
toolbar = self.addToolBar('My tools')
toolbar.addAction(openfile)
toolbar.addAction(go)
toolbar.addAction(clearstats)
toolbar.addAction(sep1)
toolbar.addAction(showpoint)
toolbar.addAction(sep2)
toolbar.addAction(quitapp)
toolbar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
toolbar.setIconSize(QtCore.QSize(30, 30))
# Status bar
self.statusBar().show()
# Main widget (everything that's not toolbar, statusbar or menubar must be in this widget)
self.scatola = QWidget()
# Main horizontal impagination
hBox = QHBoxLayout()
hBox.setSpacing(5)
# Vertical left column
vBox_left = QVBoxLayout()
vBox_left.setSpacing(5)
# 1st vertical box, a list
self.tracklist = QListWidget()
vBox_left.addWidget(self.tracklist)
self.tracklist.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.tracklist.itemSelectionChanged.connect(selection_changed)
self.tracklist.setMaximumHeight(120)
# 2nd vertical box, containing several horizontal boxes, one for each setting
vBox2 = QVBoxLayout()
vBox2.setSpacing(5)
# Just the group label
labelSettings = QLabel('Settings')
vBox2.addWidget(labelSettings)
# Use/don't use corrected altitude
self.checkUseSRTM = QCheckBox(
"Use SRTM corrected elevation (needs Internet)")
self.checkUseSRTM.setChecked(False)
vBox2.addWidget(self.checkUseSRTM)
# Choose processing method + use/don't use acceleration
hBoxProcessingMethod = QHBoxLayout()
labelProcessingMethod = QLabel('Processing method')
hBoxProcessingMethod.addWidget(labelProcessingMethod)
self.comboBoxProcessingMethod = QComboBox()
self.comboBoxProcessingMethod.addItem("Just use available data")
self.comboBoxProcessingMethod.addItem(
"Fill all gaps at T=1s (resample)")
self.comboBoxProcessingMethod.addItem("Fill only smaller gaps at T=1s")
hBoxProcessingMethod.addWidget(self.comboBoxProcessingMethod)
self.checkUseAcceleration = QCheckBox("Use acceleration")
self.checkUseAcceleration.setChecked(False)
hBoxProcessingMethod.addWidget(self.checkUseAcceleration)
vBox2.addLayout(hBoxProcessingMethod)
# Use/don't use variance smooth
self.checkExtraSmooth = QCheckBox("Extra smooth")
self.checkExtraSmooth.setChecked(False)
vBox2.addWidget(self.checkExtraSmooth)
# 2D interactive map settings
hBox2DMap = QHBoxLayout()
self.checkUseRDP = QCheckBox("Use RDP to reduce points")
self.checkUseRDP.setChecked(False)
hBox2DMap.addWidget(self.checkUseRDP)
self.check2DMapInExternalBrowser = QCheckBox(
"Show in external browser")
self.check2DMapInExternalBrowser.setChecked(False)
hBox2DMap.addWidget(self.check2DMapInExternalBrowser)
vBox2.addLayout(hBox2DMap)
# Settings for the 3D map
line3DViewSettings = QFrame()
#line3DViewSettings.setGeometry(QtCore.QRect(320, 150, 118, 3))
line3DViewSettings.setFrameShape(QFrame.HLine)
line3DViewSettings.setFrameShadow(QFrame.Sunken)
vBox2.addWidget(line3DViewSettings)
label3DViewSettings = QLabel('3D view settings')
vBox2.addWidget(label3DViewSettings)
hBox3DMapSelection = QHBoxLayout()
self.check3DMapSelection = QCheckBox(
"Select elevation tiles automatically, otherwise")
self.check3DMapSelection.setChecked(True)
hBox3DMapSelection.addWidget(self.check3DMapSelection)
self.text3DMapName = QLineEdit()
self.text3DMapName.setText("Iceland.tif")
hBox3DMapSelection.addWidget(self.text3DMapName)
vBox2.addLayout(hBox3DMapSelection)
hBox3D = QHBoxLayout()
label3DMargin = QLabel('Margin')
hBox3D.addWidget(label3DMargin)
self.spinbox3DMargin = QSpinBox()
self.spinbox3DMargin.setRange(50, 1000)
self.spinbox3DMargin.setValue(100)
self.spinbox3DMargin.setSingleStep(10)
hBox3D.addWidget(self.spinbox3DMargin)
labelSpace = QLabel(' ')
hBox3D.addWidget(labelSpace)
label3DElevationScale = QLabel('Elev. scale')
hBox3D.addWidget(label3DElevationScale)
self.spinbox3DElevationScale = QDoubleSpinBox()
self.spinbox3DElevationScale.setRange(1, 50)
self.spinbox3DElevationScale.setSingleStep(0.1)
hBox3D.addWidget(self.spinbox3DElevationScale)
hBox3D.addWidget(labelSpace)
label3DOSMZoom = QLabel('Zoom')
hBox3D.addWidget(label3DOSMZoom)
self.spinbox3DOSMZoom = QSpinBox()
self.spinbox3DOSMZoom.setRange(8, 15)
self.spinbox3DOSMZoom.setValue(13)
self.spinbox3DOSMZoom.setSingleStep(1)
hBox3D.addWidget(self.spinbox3DOSMZoom)
hBox3D.addWidget(labelSpace)
self.check3DOSMInvert = QCheckBox("Invert")
self.check3DOSMInvert.setChecked(False)
hBox3D.addWidget(self.check3DOSMInvert)
vBox2.addLayout(hBox3D)
vBox_left.addLayout(vBox2)
# 3rd stats tree
lineTree = QFrame()
lineTree.setFrameShape(QFrame.HLine)
lineTree.setFrameShadow(QFrame.Sunken)
vBox2.addWidget(lineTree)
labelTree = QLabel('Track stats')
vBox2.addWidget(labelTree)
self.tree = QTreeView()
self.tree.setSelectionBehavior(QAbstractItemView.SelectRows)
self.treemodel = QtGui.QStandardItemModel()
self.treemodel.setHorizontalHeaderLabels(['Name', 'Value'])
self.tree.setModel(self.treemodel)
self.tree.setUniformRowHeights(True)
self.tree.setColumnWidth(0, 200)
vBox_left.addWidget(self.tree)
# 4th text, containing text messages/errors
self.textWarningConsole = QTextEdit()
self.textWarningConsole.setReadOnly(True)
self.textWarningConsole.setFont(QtGui.QFont("Courier New", FONTSIZE))
self.textWarningConsole.clear()
self.textWarningConsole.setMaximumHeight(50)
vBox_left.addWidget(self.textWarningConsole)
# I put "vBox_left" inside a widget and then the widget inside "hBox"
# instead of just doing "hBox.addLayout(vBox_left) so I can set its
# maximum width.
vBox_left_widget = QWidget()
vBox_left_widget.setLayout(vBox_left)
vBox_left_widget.setMinimumWidth(400)
vBox_left_widget.setMaximumWidth(500)
hBox.addWidget(vBox_left_widget)
# Vertical right column
self.tab = QTabWidget()
# Tab 1: Summary: elevation and speed
tab1 = QWidget()
# The tab layout
vBox_tab = QVBoxLayout()
vBox_tab.setSpacing(5)
# Plot area
self.plotEmbeddedElevationAndSpeed = EmbeddedPlot_ElevationSpeed(
width=5, height=4, dpi=100)
self.plotEmbeddedElevationAndSpeed.setMinimumWidth(800)
# Add toolbar to the plot
self.mpl_toolbar1 = NavigationToolbar(
self.plotEmbeddedElevationAndSpeed, self.scatola)
# Add widgets to the layout
vBox_tab.addWidget(self.plotEmbeddedElevationAndSpeed)
vBox_tab.addWidget(self.mpl_toolbar1)
# Associate the layout to the tab
tab1.setLayout(vBox_tab)
# Tab 2: html 2D map
tab2 = QWidget()
# The tab layout
vBox_tab = QVBoxLayout()
vBox_tab.setSpacing(5)
# Area
self.map2d = QtWebEngineWidgets.QWebEngineView()
# Add widgets to the layout
vBox_tab.addWidget(self.map2d)
# Associate the layout to the tab
tab2.setLayout(vBox_tab)
# Tab 3: 3D plot
tab3 = QWidget()
# The tab layout
vBox_tab = QVBoxLayout()
vBox_tab.setSpacing(5)
# Area
self.map3d = MayaviQWidget()
# Add widgets to the layout
vBox_tab.addWidget(self.map3d)
# Associate the layout to the tab
tab3.setLayout(vBox_tab)
# Tab 4: Details
tab4 = QWidget()
# The tab layout
vBox_tab = QVBoxLayout()
vBox_tab.setSpacing(5)
# Plot area
self.plotEmbeddedDetails = EmbeddedPlot_Details(width=5,
height=4,
dpi=100)
self.plotEmbeddedDetails.setMinimumWidth(800)
# Add toolbar to the plot
self.mpl_toolbar2 = NavigationToolbar(self.plotEmbeddedDetails,
self.scatola)
# Add widgets to the layout
vBox_tab.addWidget(self.plotEmbeddedDetails)
vBox_tab.addWidget(self.mpl_toolbar2)
# Associate the layout to the tab
tab4.setLayout(vBox_tab)
# Associate tabs
self.tab.addTab(tab1, "Summary")
self.tab.addTab(tab2, "2D Map")
self.tab.addTab(tab3, "3D Map")
self.tab.addTab(tab4, "Details")
hBox.addWidget(self.tab)
# Setting hBox as main box
self.scatola.setLayout(hBox)
self.setCentralWidget(self.scatola)
# Application settings
self.setWindowTitle('TrackAnalyser')
self.setWindowIcon((QtGui.QIcon('icons/app.png')))
self.setGeometry(100, 100, 1200, 700)
self.show()
def _setup_ui(self):
# self.setGeometry(0, 0, 1600, 900)
self.main_widget = QFrame()
self.main_widget.setObjectName('ServConf')
self.setCentralWidget(self.main_widget)
self.layout = QGridLayout()
self.main_widget.setLayout(self.layout)
# Basic widgets
self.editor = QTableView()
self.delete_button = QPushButton('Delete', self)
self.delete_button.setObjectName('DeleteButton')
self.rename_button = QPushButton('Rename', self)
self.rename_button.setObjectName('RenameButton')
self.d_editor = QTableView()
self.retrieve_button = QPushButton('Retrieve', self)
self.retrieve_button.setObjectName('RetrieveButton')
self.tree = QTreeView(self)
self.config_type = QComboBox(parent=self)
self.config_type.setModel(
ConfigTypeModel(self._model, self.config_type))
# Tab widgets
self.tab1 = QWidget()
self.tab1.layout = QVBoxLayout(self.tab1)
self.tab2 = QWidget()
self.tab2.layout = QVBoxLayout(self.tab2)
self.tab1.layout.addWidget(self.editor)
hlay = QHBoxLayout()
hlay.addWidget(self.rename_button)
hlay.addWidget(self.delete_button)
self.tab1.layout.addLayout(hlay)
self.tab2.layout.addWidget(self.d_editor)
self.tab2.layout.addWidget(self.retrieve_button)
self.editor_tab = QTabWidget(self)
self.editor_tab.addTab(self.tab1, 'Configurations')
self.editor_tab.addTab(self.tab2, 'Discarded Configurations')
self.config_viewer = QWidget(self)
self.config_viewer.layout = QVBoxLayout(self.config_viewer)
self.config_viewer.layout.addWidget(self.editor_tab)
self.config_viewer.layout.addWidget(self.tree)
# Header widget
self.header = QFrame(self)
self.header.setObjectName('Header')
self.header.layout = QHBoxLayout(self.header)
self.header.layout.addStretch()
self.header.layout.addWidget(
QLabel('Configuration Database Manager', self.header))
self.header.layout.addStretch()
# Sub header with database genral information
self.sub_header = QFrame(self)
self.sub_header.setObjectName('SubHeader')
self.sub_header.layout = QVBoxLayout(self.sub_header)
self.server_layout = QHBoxLayout()
self.server_layout.addWidget(QLabel('<b>Server:</b>', self.sub_header))
self.server_layout.addWidget(QLabel(self._model.url, self.sub_header))
self.server_layout.addStretch()
self.size_layout = QHBoxLayout()
self.size_layout.addWidget(QLabel('<b>DB Size:</b>', self.sub_header))
try:
dbsize = self._model.get_dbsize()
dbsize = '{:.2f} MB'.format(dbsize/(1024*1024))
except ConfigDBException:
dbsize = 'Failed to retrieve information'
self.size_layout.addWidget(QLabel(dbsize, self.sub_header))
self.size_layout.addStretch()
self.sub_header.layout.addLayout(self.server_layout)
self.sub_header.layout.addLayout(self.size_layout)
# Query form
self.query_form = QFrame()
self.query_form.setObjectName("QueryForm")
self.query_form.layout = QVBoxLayout()
self.query_form.setLayout(self.query_form.layout)
self.configs_layout = QGridLayout()
self.configs_layout.addWidget(QLabel('Configurations:', self), 0, 0)
self.nr_configs = QLabel(self)
self.configs_layout.addWidget(self.nr_configs, 0, 1)
self.configs_layout.addWidget(QLabel('Discarded:', self), 0, 2)
self.nr_discarded = QLabel(self)
self.configs_layout.addWidget(self.nr_discarded, 0, 3)
self.query_form.layout.addWidget(self.config_type)
self.query_form.layout.addLayout(self.configs_layout)
# Main widget layout setup
self.layout.addWidget(self.header, 0, 0, 1, 3)
self.layout.addWidget(self.sub_header, 1, 0, 1, 2)
self.layout.addWidget(self.query_form, 2, 0, 1, 2)
self.layout.addWidget(self.config_viewer, 3, 0, 1, 2)
self.layout.addWidget(self.tree, 1, 2, 4, 1)
# self.layout.addWidget(self.delete_button, 4, 0, 1, 2)
self.layout.setColumnStretch(0, 1)
self.layout.setColumnStretch(1, 2)
self.layout.setColumnStretch(2, 2)
# Set table models and options
self.editor_model = ConfigDbTableModel('notexist', self._model)
self.d_editor_model = ConfigDbTableModel('notexist', self._model, True)
self.editor.setModel(self.editor_model)
self.editor.setSelectionBehavior(self.editor.SelectRows)
self.editor.setSortingEnabled(True)
self.editor.horizontalHeader().setResizeMode(QHeaderView.Stretch)
self.d_editor.setModel(self.d_editor_model)
self.d_editor.setSelectionBehavior(self.editor.SelectRows)
self.d_editor.setSortingEnabled(True)
self.d_editor.horizontalHeader().setResizeMode(QHeaderView.Stretch)
self.d_editor.setSelectionMode(self.d_editor.SingleSelection)
# Set tree model and options
self.tree_model = JsonTreeModel(None, None, self._model)
self.tree.setModel(self.tree_model)
# Delete button
self.delete_button.setEnabled(False)
self.rename_button.setEnabled(True)
self.retrieve_button.setEnabled(False)
# Signals and slots
# Tab
self.editor_tab.currentChanged.connect(self._tab_changed)
# Fill tables when configuration is selected
self.config_type.currentTextChanged.connect(self._fill_table)
# Fill tree when a configuration is selected
self.editor.selectionModel().selectionChanged.connect(
lambda x, y: self._fill_tree())
self.d_editor.selectionModel().selectionChanged.connect(
lambda x, y: self._fill_tree())
# Connect database error to slot that show messages
self.editor_model.connectionError.connect(self._database_error)
self.d_editor_model.connectionError.connect(self._database_error)
# Makes tree column extend automatically to show content
self.tree.expanded.connect(
lambda idx: self.tree.resizeColumnToContents(idx.column()))
# Button action
self.delete_button.pressed.connect(self._remove_configuration)
self.rename_button.pressed.connect(self._rename_configuration)
self.retrieve_button.pressed.connect(self._retrieve_configuration)
# Set constants
ConfigurationManager.NAME_COL = \
self.editor_model.horizontalHeader.index('name')
ConfigurationManager.CONFIG_TYPE_COL = \
self.editor_model.horizontalHeader.index('config_type')
self.editor.resizeColumnsToContents()
self.d_editor.resizeColumnsToContents()
'analyze_getval', obj, args)
if isinstance(data, (pd.DataFrame, pd.Index, pd.Series)):
dialog = DataFrameEditor(self)
dialog.setup_and_check(data)
elif isinstance(data, (np.ndarray, np.ma.MaskedArray)):
dialog = ArrayEditor(self)
dialog.setup_and_check(data, title='', readonly=True)
elif isinstance(data, (list, set, tuple, dict)):
dialog = CollectionsEditor(self)
dialog.setup(data, title='', readonly=True)
else:
return
dialog.show()
@property
def shell(self):
return self.parent().parent().shellwidget
if __name__ == '__main__':
app = QApplication(sys.argv)
model = MxAnalyzerModel()
view = QTreeView()
view.setModel(model)
view.setWindowTitle("Simple Tree Model")
view.show()
sys.exit(app.exec_())
app = QApplication(sys.argv)
#QTreeView()
model = TansuModel()
for x in range(0, 4):
model.insertNewIndex(x, str('node%s' % x))
#model.insertRows(0, 3, QModelIndex())
#index = model.index(0, 1, QModelIndex())
#item = model.getItem(index)
#parent_index = model.index(0, 1, QModelIndex())
#parent_item = parent_index.internalPointer()
#TansuModelItem("child", parent_item)
tree_view = QTreeView()
tree_view.move(QCursor.pos())
tree_view.setDragEnabled(True)
tree_view.setDragDropOverwriteMode(False)
tree_view.setSelectionMode(QAbstractItemView.MultiSelection)
# tree_view.viewport().setAcceptDrops(True)
# tree_view.setDropIndicatorShown(True)
tree_view.setDragDropMode(QAbstractItemView.DragDropMode.InternalMove)
tree_view.setModel(model)
list_view = QListView()
list_view.move(QCursor.pos())
list_view.setDragDropOverwriteMode(False)
def create_widget(self):
self.widget = QTreeView(self.parent_widget())
def __init__(self, parent=None):
super().__init__(parent)
self.tree_view = QTreeView(parent)
self.tree_view.setAlternatingRowColors(True)
def __init__(self, settings, path=None):
super(RootWidget, self).__init__()
# --- setup the file system model ---
model = QFileSystemModel()
model.setRootPath('This PC')
model.setReadOnly(False)
model.setIconProvider(
JSONFileIconProvider('file_view_icons.json')
)
model.setFilter(
QDir.AllEntries | QDir.NoDotAndDotDot | QDir.AllDirs | QDir.Hidden
)
self._model = FileSystemProxyModel()
self._model.setSourceModel(model)
# --- setup the tree view ---
self._view = QTreeView()
self._view.setModel(self._model)
self._view.setSelectionMode(QTreeView.ExtendedSelection)
self._view.activated.connect(self._handle_activated_index)
self._view.setSortingEnabled(True)
self._view.setHeaderHidden(True)
self._view.setExpandsOnDoubleClick(False)
self._view.sortByColumn(0, Qt.AscendingOrder)
# Setup drag and drop.
self._view.setDragDropMode(QTreeView.DragDrop)
self._view.setDefaultDropAction(Qt.MoveAction)
# Setup the columns that show.
self._view.hideColumn(1)
self._view.hideColumn(2)
self._view.hideColumn(3)
# Note that the double click trigger cannot be in this list, otherwise it flashes in edit
# mode before opening the file
self._view.setEditTriggers(
QTreeView.SelectedClicked | QTreeView.EditKeyPressed)
# setup the context menu
self._view.setContextMenuPolicy(Qt.CustomContextMenu)
self._view.customContextMenuRequested.connect(self._context_menu)
# Unselect items on collapse.
self._view.collapsed.connect(self._view.clearSelection)
# --- setup the current root path label ---
self._root_edit = PathEdit()
self._root_edit.new_path.connect(self._set_root_path)
# --- setup the tool bar ---
tool_bar = QToolBar()
new_file_action = QAction('New File', self)
tool_bar.addAction(new_file_action)
tool_bar.widgetForAction(new_file_action).setObjectName('new_file')
new_file_action.triggered.connect(self._create_file)
new_directory_action = QAction('New Directory', self)
tool_bar.addAction(new_directory_action)
tool_bar.widgetForAction(new_directory_action).setObjectName('new_directory')
new_directory_action.triggered.connect(self._create_directory)
close_action = QAction('Close', self)
tool_bar.addAction(close_action)
self._close_widget = tool_bar.widgetForAction(close_action)
self._close_widget.setObjectName('close_root')
close_action.triggered.connect(self.close_request.emit)
# --- setup the layout ---
main_layout = QVBoxLayout()
main_layout.setContentsMargins(0, 0, 0, 0)
main_layout.setSpacing(0)
path_layout = QHBoxLayout()
path_layout.setContentsMargins(0, 0, 0, 0)
main_layout.setSpacing(0)
path_layout.addWidget(self._root_edit)
path_layout.addWidget(tool_bar)
main_layout.addLayout(path_layout)
main_layout.addWidget(self._view)
self.setLayout(main_layout)
if path is not None:
self._set_root_path(path)
self._root_edit.update(path)
self._settings = None
self.update_settings(settings)
