class MVCConfigurationGUI(MVCConfigurationBase):
"""
GUI implementation of MVCConfigurationBase
"""
def __init__(self, configuration):
super().__init__(configuration)
assertMainThread()
srv = Services.getService("MainWindow")
srv.aboutToClose.connect(self._aboutToClose)
confMenu = srv.menuBar().addMenu("&Configuration")
toolBar = srv.getToolBar()
configuration.configNameChanged.connect(self._configNameChanged)
configuration.dirtyChanged.connect(self._dirtyChanged)
style = QApplication.style()
self.actLoad = QAction(
QIcon.fromTheme("document-open",
style.standardIcon(QStyle.SP_DialogOpenButton)),
"Open config", self)
self.actLoad.triggered.connect(self._execLoad)
self.actSave = QAction(
QIcon.fromTheme("document-save",
style.standardIcon(QStyle.SP_DialogSaveButton)),
"Save config", self)
self.actSave.triggered.connect(self._execSaveConfig)
self.actSaveWithGuiState = QAction(
QIcon.fromTheme("document-save",
style.standardIcon(QStyle.SP_DialogSaveButton)),
"Save config sync gui state", self)
self.actSaveWithGuiState.triggered.connect(
self._execSaveConfigWithGuiState)
self.actNew = QAction(
QIcon.fromTheme("document-new",
style.standardIcon(QStyle.SP_FileIcon)),
"New config", self)
self.actNew.triggered.connect(self._execNew)
self.actActivate = QAction(
QIcon.fromTheme("arrow-up", style.standardIcon(QStyle.SP_ArrowUp)),
"Initialize", self)
self.actActivate.triggered.connect(self.activate)
self.actDeactivate = QAction(
QIcon.fromTheme("arrow-down",
style.standardIcon(QStyle.SP_ArrowDown)),
"Deinitialize", self)
self.actDeactivate.triggered.connect(self.deactivate)
confMenu.addAction(self.actLoad)
confMenu.addAction(self.actSave)
confMenu.addAction(self.actSaveWithGuiState)
confMenu.addAction(self.actNew)
confMenu.addAction(self.actActivate)
confMenu.addAction(self.actDeactivate)
toolBar.addAction(self.actLoad)
toolBar.addAction(self.actSave)
toolBar.addAction(self.actNew)
toolBar.addAction(self.actActivate)
toolBar.addAction(self.actDeactivate)
self.recentConfigs = [QAction() for i in range(10)]
self.recentConfigs[0].setShortcut(QKeySequence(Qt.CTRL + Qt.Key_R))
confMenu.addSeparator()
recentMenu = confMenu.addMenu("Recent")
for a in self.recentConfigs:
a.setVisible(False)
a.triggered.connect(self._openRecent)
recentMenu.addAction(a)
self.mainWidget = srv.newDockWidget("Configuration", None,
Qt.LeftDockWidgetArea)
self.treeView = QTreeView(self.mainWidget)
self.treeView.setHeaderHidden(False)
self.treeView.setSelectionMode(QAbstractItemView.NoSelection)
self.treeView.setEditTriggers(self.treeView.EditKeyPressed
| self.treeView.AnyKeyPressed)
self.treeView.setAllColumnsShowFocus(True)
self.treeView.setExpandsOnDoubleClick(False)
self.treeView.setDragEnabled(True)
self.treeView.setDropIndicatorShown(True)
self.treeView.setDragDropMode(QAbstractItemView.DragOnly)
self.mainWidget.setWidget(self.treeView)
self.treeView.setModel(self.model)
self.treeView.header().setStretchLastSection(True)
self.treeView.header().setSectionResizeMode(
0, QHeaderView.ResizeToContents)
self.treeView.doubleClicked.connect(self._onItemDoubleClicked)
self.treeView.setContextMenuPolicy(Qt.CustomContextMenu)
self.treeView.customContextMenuRequested.connect(
self._execTreeViewContextMenu)
# expand applications by default
self.treeView.setExpanded(self.model.index(1, 0), True)
self.delegate = PropertyDelegate(self.model, ITEM_ROLE,
ConfigurationModel.PropertyContent,
self)
self.treeView.setItemDelegate(self.delegate)
self.restoreState()
srv.aboutToClose.connect(self.saveState)
# a list of dock widgets displaying subgraphs
self._graphViews = []
# make sure that the graph views are closed when the config is closed
self._configuration.subConfigRemoved.connect(self._subConfigRemoved)
self._waitForActivated = None
self._waitForOpenState = None
def _execLoad(self):
assertMainThread()
if self._checkDirty():
return
fn, _ = QFileDialog.getOpenFileName(self.mainWidget,
"Load configuration",
self.cfgfile,
filter="*.json")
if fn is not None and fn != "":
logger.debug("Loading config file %s", fn)
try:
self.loadConfig(fn)
except Exception as e: # pylint: disable=broad-except
logger.exception("Error while loading configuration %s: %s",
fn, str(e))
QMessageBox.warning(self.mainWidget,
"Error while loading configuration",
str(e))
def _openRecent(self):
"""
Called when the user clicks on a recent config.
:return:
"""
if self._checkDirty():
return
action = self.sender()
fn = action.data()
try:
self.loadConfig(fn)
except Exception as e: # pylint: disable=broad-except
# catching general exception is wanted here.
logger.exception("Error while loading configuration %s: %s", fn,
str(e))
QMessageBox.warning(self.mainWidget,
"Error while loading configuration", str(e))
def _checkDirty(self):
if self._configuration.dirty():
ans = QMessageBox.question(
None,
"Save changes?",
"There are unsaved changes. Do you want to save them?",
buttons=QMessageBox.Save | QMessageBox.Discard
| QMessageBox.Cancel,
defaultButton=QMessageBox.Save)
if ans == QMessageBox.Save:
self.saveConfig()
return False
if ans == QMessageBox.Cancel:
return True
return False
def _aboutToClose(self, mainWindow):
if self._checkDirty():
mainWindow.ignoreCloseEvent()
def _execNew(self):
assertMainThread()
if self._checkDirty():
return
fn, _ = QFileDialog.getSaveFileName(self.mainWidget,
"New configuration",
".",
filter="*.json")
if fn is not None and fn != "":
logger.debug("Creating config file %s", fn)
self.newConfig(fn)
def _execSaveConfig(self):
if self.configuration().filename() is None:
self._execSaveConfigAs()
else:
self.saveConfig()
def _execSaveConfigWithGuiState(self):
if self.configuration().filename() is None:
self._execSaveConfigAs()
else:
self.saveConfigWithGuiState()
def _execSaveConfigAs(self):
"""
Opens a file dialog to get the save file name and calls saveConfig.
:return:
"""
assertMainThread()
fn, _ = QFileDialog.getSaveFileName(self.mainWidget,
"Save configuration as", ".",
"*.json")
if fn is not None and fn != "":
self.saveConfigAs(fn)
def _addGraphView(self, subConfig):
g = subConfig.getGraph()
# remove already deleted graph views from internal list
valid_graphViews = []
for gv in self._graphViews:
if shiboken2.isValid(gv): # pylint: disable=no-member
valid_graphViews.append(gv)
self._graphViews = valid_graphViews
# check if graph view is already there
for gv in self._graphViews:
if gv.widget().scene().graph == g:
logger.info("Graph view already exists.")
return
# create new graph view
srv = Services.getService("MainWindow")
graphDw = srv.newDockWidget("Graph (%s)" % (subConfig.getName()),
parent=None,
defaultArea=Qt.RightDockWidgetArea,
allowedArea=Qt.RightDockWidgetArea
| Qt.BottomDockWidgetArea)
graphDw.setAttribute(Qt.WA_DeleteOnClose, True)
assert isinstance(graphDw, QDockWidget)
graphView = GraphEditorView(graphDw)
graphView.setScene(GraphScene(subConfig.getGraph(), graphDw))
graphDw.setWidget(graphView)
self._graphViews.append(graphDw)
graphDw.visibleChanged.connect(self._removeGraphViewFromList)
def _subConfigRemoved(self, subConfigName, configType):
g = self._configuration.subConfigByNameAndTye(subConfigName,
configType).getGraph()
for gv in self._graphViews:
if gv.widget().scene().graph == g:
logger.debug("deleting graph view for subconfig %s",
subConfigName)
gv.deleteLater()
def _removeGraphViewFromList(self, visible):
if visible:
return
gv = self.sender()
try:
self._graphViews.remove(gv)
logger.debug("removed graphview from list")
except ValueError:
logger.debug("graphview not in list, ignored")
def _execTreeViewContextMenu(self, point):
index = self.treeView.indexAt(point)
item = self.model.data(index, ITEM_ROLE)
if isinstance(item, ConfigurationModel.SubConfigContent):
m = QMenu()
a1 = QAction("Edit graph")
m.addAction(a1)
a1.triggered.connect(lambda: self._addGraphView(item.subConfig))
if self.model.isApplication(index):
a2 = QAction("Select Application")
a2.triggered.connect(lambda: self.changeActiveApp(
self.model.data(index, Qt.DisplayRole)))
a3 = QAction("Init Application")
a3.triggered.connect(lambda: self._changeActiveAppAndInit(
self.model.data(index, Qt.DisplayRole)))
m.addActions([a2, a3])
pbsrv = Services.getService("PlaybackControl")
m2 = m.addMenu("Init and load sequence")
m3 = m.addMenu("Init, load and play")
s1 = []
s2 = []
for a in pbsrv.recentSeqs:
assert isinstance(a, QAction)
if a.isVisible():
# pylint: disable=cell-var-from-loop
# the below statements are tested and work
aseq = QAction(a.text())
aseq.triggered.connect(lambda arg1=a.data(
), seq=a.data(): self._changeActiveAppInitAndLoad(
self.model.data(index, Qt.DisplayRole), seq, False)
)
s1.append(aseq)
aseq = QAction(a.text())
aseq.triggered.connect(lambda arg1=a.data(
), seq=a.data(): self._changeActiveAppInitAndLoad(
self.model.data(index, Qt.DisplayRole), seq, True))
# pylint: enable=cell-var-from-loop
s2.append(aseq)
m2.addActions(s1)
m3.addActions(s2)
m.exec_(self.treeView.mapToGlobal(point))
return
if self.model.isSubConfigParent(
index) == Configuration.CONFIG_TYPE_APPLICATION:
m = QMenu()
a = QAction("Add application")
m.addAction(a)
a = m.exec_(self.treeView.mapToGlobal(point))
if a is not None:
self._configuration.addNewApplication()
return
if self.model.isSubConfigParent(
index) == Configuration.CONFIG_TYPE_COMPOSITE:
m = QMenu()
a = QAction("Add composite filter")
m.addAction(a)
a = m.exec_(self.treeView.mapToGlobal(point))
if a is not None:
self._configuration.addNewCompositeFilter()
return
def _configNameChanged(self, cfgfile):
logger.debug("_configNameChanged: %s", cfgfile)
assertMainThread()
self.cfgfile = cfgfile
self._dirtyChanged(self._configuration.dirty())
foundIdx = None
for i, a in enumerate(self.recentConfigs):
if a.data() == cfgfile:
foundIdx = i
if foundIdx is None:
foundIdx = len(self.recentConfigs) - 1
for i in range(foundIdx, 0, -1):
self.recentConfigs[i].setText(self.recentConfigs[i - 1].text())
self.recentConfigs[i].setData(self.recentConfigs[i - 1].data())
self.recentConfigs[i].setVisible(
self.recentConfigs[i - 1].data() is not None)
self.recentConfigs[0].setText(cfgfile)
self.recentConfigs[0].setData(cfgfile)
self.recentConfigs[0].setVisible(True)
def _dirtyChanged(self, dirty):
srv = Services.getService("MainWindow")
if self.cfgfile is None:
title = "nexxT: <unnamed>"
else:
title = "nexxT: " + self.cfgfile
if dirty:
title += " *"
srv.setWindowTitle(title)
def _onItemDoubleClicked(self, index):
assertMainThread()
if self.model.isApplication(index):
app = self.model.data(index, Qt.DisplayRole)
self.changeActiveApp(app)
else:
self.treeView.edit(index)
def _changeActiveAppAndInit(self, app):
"""
Call this slot to activate and init an application
:param app: can be either an Application instance or the name of an application
:return:
"""
assertMainThread()
if isinstance(app, str):
app = self.configuration().applicationByName(app)
currentApp = Application.activeApplication
if currentApp is not None:
currentApp = currentApp.getApplication()
self._waitForActivated = app
self.changeActiveApp(app.getName())
def _changeActiveAppInitAndLoad(self, app, sequence, startPlay):
self._waitForOpenState = (app, sequence, startPlay)
self._changeActiveAppAndInit(app)
def appActivated(self, name, app): # pylint: disable=unused-argument
"""
Called when the application is activated.
:param name: the application name
:param app: An ActiveApplication instance.
:return:
"""
assertMainThread()
if app is not None:
self.activeAppStateChange(app.getState())
app.stateChanged.connect(self.activeAppStateChange)
if self._waitForActivated == app.getApplication():
MethodInvoker(self.activate, Qt.QueuedConnection)
else:
self.actActivate.setEnabled(False)
self.actDeactivate.setEnabled(False)
self._waitForActivated = None
def _disconnectSingleShotPlay(self):
assertMainThread()
pbsrv = Services.getService("PlaybackControl")
try:
pbsrv.playbackPaused.disconnect(self._singleShotPlay)
except RuntimeError:
# we are already disconnected.
pass
def _singleShotPlay(self):
assertMainThread()
pbsrv = Services.getService("PlaybackControl")
MethodInvoker(pbsrv.startPlayback, Qt.QueuedConnection)
self._disconnectSingleShotPlay()
def activeAppStateChange(self, newState):
"""
Called when the active application changes its state.
:param newState: the new application's state (see FilterState)
:return:
"""
assertMainThread()
if newState == FilterState.CONSTRUCTED:
self.actActivate.setEnabled(True)
else:
self.actActivate.setEnabled(False)
if newState == FilterState.ACTIVE:
if self._waitForOpenState is not None:
app, pbfile, startPlay = self._waitForOpenState
self._waitForOpenState = None
if app == Application.activeApplication.getApplication(
).getName():
pbsrv = Services.getService("PlaybackControl")
if startPlay:
pbsrv.playbackPaused.connect(self._singleShotPlay)
QTimer.singleShot(2000, self._disconnectSingleShotPlay)
MethodInvoker(pbsrv.browser.setActive, Qt.QueuedConnection,
pbfile)
self.actDeactivate.setEnabled(True)
self.actSaveWithGuiState.setEnabled(False)
else:
self.actDeactivate.setEnabled(False)
self.actSaveWithGuiState.setEnabled(True)
def restoreState(self):
"""
Restore the state of the configuration gui service (namely the recently
open config files). This is saved in QSettings because it is used
across config files.
:return:
"""
logger.debug("restoring config state ...")
settings = QSettings()
v = settings.value("ConfigurationRecentFiles")
if v is not None and isinstance(v, QByteArray):
ds = QDataStream(v)
recentFiles = ds.readQStringList()
idx = 0
for f in recentFiles:
if f != "" and f is not None:
self.recentConfigs[idx].setData(f)
self.recentConfigs[idx].setText(f)
self.recentConfigs[idx].setVisible(True)
idx += 1
if idx >= len(self.recentConfigs):
break
logger.debug("restoring config state done")
def saveState(self):
"""
Save the state of the configuration gui service (namely the recently
open config files). This is saved in QSettings because it is used
across config files.
:return:
"""
logger.debug("saving config state ...")
settings = QSettings()
b = QByteArray()
ds = QDataStream(b, QIODevice.WriteOnly)
l = [
rc.data() for rc in self.recentConfigs
if rc.isVisible() and rc.data() is not None and rc.data() != ""
]
ds.writeQStringList(l)
settings.setValue("ConfigurationRecentFiles", b)
logger.debug("saving config state done (%s)", l)
def create_ui(self):
"""Setup main UI elements, dock widgets, UI-related elements, etc.
"""
log.debug('Loading UI')
# Undo Stack
self.undo_stack = QUndoStack(self)
self.undo_stack.setUndoLimit(100)
# Object navigation history
self.obj_history = deque([], config.MAX_OBJ_HISTORY)
app = QApplication.instance()
base_font = QFont()
base_font.fromString(self.prefs['base_font'])
app.setFont(base_font)
# Object class table widget
# classTable = QTableView(self)
classTable = classtable.TableView(self)
classTable.setObjectName("classTable")
classTable.setAlternatingRowColors(True)
classTable.setFrameShape(QFrame.StyledPanel)
classTable_font = QFont()
classTable_font.fromString(self.prefs['class_table_font'])
classTable.setFont(classTable_font)
fm = classTable.fontMetrics()
classTable.setWordWrap(True)
classTable.setEditTriggers(QAbstractItemView.EditKeyPressed |
QAbstractItemView.DoubleClicked |
QAbstractItemView.AnyKeyPressed |
QAbstractItemView.SelectedClicked)
# classTable.horizontalHeader().setMovable(True)
# classTable.verticalHeader().setMovable(False)
classTable.horizontalHeader().setSectionResizeMode(QHeaderView.Interactive)
classTable.verticalHeader().setSectionResizeMode(QHeaderView.Interactive)
classTable.horizontalHeader().setDefaultSectionSize(self.prefs['default_column_width'])
classTable.verticalHeader().setDefaultSectionSize(fm.height() + 0)
classTable.setSelectionMode(QAbstractItemView.ExtendedSelection)
classTable.setContextMenuPolicy(Qt.CustomContextMenu)
classTable.customContextMenuRequested.connect(self.custom_table_context_menu)
# Create table model and proxy layers for transposing and filtering
self.classTableModel = classtable.IDFObjectTableModel(classTable)
self.transposeableModel = classtable.TransposeProxyModel(self.classTableModel)
self.transposeableModel.setSourceModel(self.classTableModel)
self.sortableModel = classtable.SortFilterProxyModel(self.transposeableModel)
self.sortableModel.setSourceModel(self.transposeableModel)
# Assign model to table (enable sorting FIRST)
# table.setSortingEnabled(True) # Disable for now, CRUD actions won't work!
classTable.setModel(self.sortableModel)
# Connect some signals
selection_model = classTable.selectionModel()
selection_model.selectionChanged.connect(self.table_selection_changed)
scroll_bar = classTable.verticalScrollBar()
scroll_bar.valueChanged.connect(self.scroll_changed)
# These are currently broken
# classTable.horizontalHeader().sectionMoved.connect(self.moveObject)
# classTable.verticalHeader().sectionMoved.connect(self.moveObject)
# Object class tree widget
classTreeDockWidget = QDockWidget("Object Classes and Counts", self)
classTreeDockWidget.setObjectName("classTreeDockWidget")
classTreeDockWidget.setAllowedAreas(Qt.AllDockWidgetAreas)
classTree = QTreeView(classTreeDockWidget)
classTree.setUniformRowHeights(True)
classTree.setAllColumnsShowFocus(True)
classTree.setRootIsDecorated(False)
classTree.setExpandsOnDoubleClick(True)
classTree.setIndentation(15)
classTree.setAnimated(True)
classTree_font = QFont()
classTree_font.fromString(self.prefs['class_tree_font'])
classTree.setFont(classTree_font)
classTree.setAlternatingRowColors(True)
classTree.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel)
palette = classTree.palette()
palette.setColor(QPalette.Highlight, Qt.darkCyan)
classTree.setPalette(palette)
class_tree_window = QWidget(classTreeDockWidget)
class_tree_dock_layout_v = QVBoxLayout()
class_tree_dock_layout_h = QHBoxLayout()
class_tree_dock_layout_v.setContentsMargins(0, 8, 0, 0)
class_tree_dock_layout_h.setContentsMargins(0, 0, 0, 0)
class_tree_filter_edit = QLineEdit(classTreeDockWidget)
class_tree_filter_edit.setPlaceholderText("Filter Classes")
class_tree_filter_edit.textChanged.connect(self.treeFilterRegExpChanged)
class_tree_filter_cancel = QPushButton("Clear", classTreeDockWidget)
class_tree_filter_cancel.setMaximumWidth(45)
class_tree_filter_cancel.clicked.connect(self.clearTreeFilterClicked)
class_tree_dock_layout_h.addWidget(class_tree_filter_edit)
class_tree_dock_layout_h.addWidget(class_tree_filter_cancel)
class_tree_dock_layout_v.addLayout(class_tree_dock_layout_h)
class_tree_dock_layout_v.addWidget(classTree)
class_tree_window.setLayout(class_tree_dock_layout_v)
classTreeDockWidget.setWidget(class_tree_window)
classTreeDockWidget.setContentsMargins(0,0,0,0)
# Comments widget
commentDockWidget = QDockWidget("Comments", self)
commentDockWidget.setObjectName("commentDockWidget")
commentDockWidget.setAllowedAreas(Qt.AllDockWidgetAreas)
commentView = UndoRedoTextEdit(commentDockWidget, self)
commentView.setLineWrapMode(QTextEdit.FixedColumnWidth)
commentView.setLineWrapColumnOrWidth(499)
commentView.setFrameShape(QFrame.StyledPanel)
commentView_font = QFont()
commentView_font.fromString(self.prefs['comments_font'])
commentView.setFont(commentView_font)
commentDockWidget.setWidget(commentView)
# Info and help widget
infoDockWidget = QDockWidget("Info", self)
infoDockWidget.setObjectName("infoDockWidget")
infoDockWidget.setAllowedAreas(Qt.AllDockWidgetAreas)
infoView = QTextEdit(infoDockWidget)
infoView.setFrameShape(QFrame.StyledPanel)
infoView.setReadOnly(True)
infoDockWidget.setWidget(infoView)
# Node list and jump menu widget
refDockWidget = QDockWidget("Field References", self)
refDockWidget.setObjectName("refDockWidget")
refDockWidget.setAllowedAreas(Qt.AllDockWidgetAreas)
ref_model = reftree.ReferenceTreeModel(None, refDockWidget)
refView = QTreeView(refDockWidget)
refView.setModel(ref_model)
refView.setUniformRowHeights(True)
refView.setRootIsDecorated(False)
refView.setIndentation(15)
refView.setColumnWidth(0, 160)
refView.setFrameShape(QFrame.StyledPanel)
refDockWidget.setWidget(refView)
refView.doubleClicked.connect(self.ref_tree_double_clicked)
# Logging and debugging widget
logDockWidget = QDockWidget("Log Viewer", self)
logDockWidget.setObjectName("logDockWidget")
logDockWidget.setAllowedAreas(Qt.AllDockWidgetAreas)
logView = QPlainTextEdit(logDockWidget)
logView.setLineWrapMode(QPlainTextEdit.NoWrap)
logView.setReadOnly(True)
logView_font = QFont()
logView_font.fromString(self.prefs['base_font'])
logView.setFont(logView_font)
logView.ensureCursorVisible()
logDockWidget.setWidget(logView)
# Undo view widget
undoDockWidget = QDockWidget("Undo History", self)
undoDockWidget.setObjectName("undoDockWidget")
undoDockWidget.setAllowedAreas(Qt.AllDockWidgetAreas)
undoView = QUndoView(self.undo_stack)
undoDockWidget.setWidget(undoView)
# Define corner docking behaviour
self.setDockNestingEnabled(True)
self.setCorner(Qt.TopLeftCorner,
Qt.LeftDockWidgetArea)
self.setCorner(Qt.TopRightCorner,
Qt.RightDockWidgetArea)
self.setCorner(Qt.BottomLeftCorner,
Qt.LeftDockWidgetArea)
self.setCorner(Qt.BottomRightCorner,
Qt.RightDockWidgetArea)
# Assign main widget and dock widgets to QMainWindow
self.setCentralWidget(classTable)
self.addDockWidget(Qt.LeftDockWidgetArea, classTreeDockWidget)
self.addDockWidget(Qt.RightDockWidgetArea, commentDockWidget)
self.addDockWidget(Qt.RightDockWidgetArea, infoDockWidget)
self.addDockWidget(Qt.RightDockWidgetArea, refDockWidget)
self.addDockWidget(Qt.RightDockWidgetArea, logDockWidget)
self.addDockWidget(Qt.RightDockWidgetArea, undoDockWidget)
# Store widgets for access by other objects
self.classTable = classTable
self.commentView = commentView
self.infoView = infoView
self.classTree = classTree
self.logView = logView
self.undoView = undoView
self.refView = refView
self.filterTreeBox = class_tree_filter_edit
# Store docks for access by other objects
self.commentDockWidget = commentDockWidget
self.infoDockWidget = infoDockWidget
self.classTreeDockWidget = classTreeDockWidget
self.logDockWidget = logDockWidget
self.undoDockWidget = undoDockWidget
self.refDockWidget = refDockWidget
# Perform other UI-related initialization tasks
self.center()
self.setUnifiedTitleAndToolBarOnMac(True)
self.setWindowIcon(QIcon(':/images/logo.png'))
# Status bar setup
self.statusBar().showMessage('Status: Ready')
self.unitsLabel = QLabel()
self.unitsLabel.setAlignment(Qt.AlignCenter)
self.unitsLabel.setMinimumSize(self.unitsLabel.sizeHint())
self.unitsLabel.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
self.statusBar().addPermanentWidget(self.unitsLabel)
self.pathLabel = QLabel()
self.pathLabel.setAlignment(Qt.AlignCenter)
self.pathLabel.setMinimumSize(self.pathLabel.sizeHint())
self.pathLabel.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
self.statusBar().addPermanentWidget(self.pathLabel)
self.versionLabel = QLabel()
self.versionLabel.setAlignment(Qt.AlignCenter)
self.versionLabel.setMinimumSize(self.versionLabel.sizeHint())
self.versionLabel.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
self.statusBar().addPermanentWidget(self.versionLabel)
self.progressBarIDF = QProgressBar()
self.progressBarIDF.setAlignment(Qt.AlignCenter)
self.progressBarIDF.setMaximumWidth(200)
self.statusBar().addPermanentWidget(self.progressBarIDF)
self.clipboard = QApplication.instance().clipboard()
self.obj_clipboard = []
self.setStyleSheet("""
QToolTip {
background-color: gray;
color: white;
border: black solid 1px
}
# QMenu {
# background-color: rgbf(0.949020, 0.945098, 0.941176);
# color: rgb(255,255,255);
# }
# QMenu::item::selected {
# background-color: rgbf(0.949020, 0.945098, 0.941176);
# }
""")
class SearchReplaceDialog(QDialog):
"""Search & Replace window
"""
def __init__(self, parent, initial_query=None):
"""Initialize the search window
"""
super(SearchReplaceDialog, self).__init__(parent)
self.parent = parent
self.prefs = parent.prefs
self.items_checked = 0
self.search_button = QPushButton('Search')
self.search_text = MySearchField(self.search_button)
self.search_text.setPlaceholderText("Enter search query here")
self.search_button.clicked.connect(self.submit_search)
input_layout = QHBoxLayout()
input_layout.addWidget(self.search_text)
input_layout.addWidget(self.search_button)
self.results_tree = QTreeView()
self.results_tree.setRootIsDecorated(False)
self.results_tree.setAlternatingRowColors(True)
self.results_tree.setAllColumnsShowFocus(True)
self.results_tree.setSelectionBehavior(QAbstractItemView.SelectRows)
self.results_tree.setSelectionMode(QAbstractItemView.SingleSelection)
self.results_tree.doubleClicked.connect(self.go_to_object)
self.whole_field_checkbox = QCheckBox("Whole Field Only", self)
self.advanced_search_checkbox = QCheckBox("Advanced Search", self)
self.advanced_search_checkbox.stateChanged.connect(
self.advanced_search_checked)
self.ignore_geometry_checkbox = QCheckBox("Ignore Geometry", self)
self.go_button = QPushButton('Go')
self.go_button.clicked.connect(self.go_to_object)
checks_layout = QHBoxLayout()
checks_layout.addWidget(self.whole_field_checkbox)
checks_layout.addWidget(self.advanced_search_checkbox)
checks_layout.addWidget(self.ignore_geometry_checkbox)
checks_layout.addStretch()
checks_layout.addWidget(self.go_button)
self.query_label = QLabel("Query:")
self.query_label.setEnabled(False)
self.query_text = QLineEdit()
self.query_text.setEnabled(True)
self.query_text.setReadOnly(True)
self.query_text.setFrame(False)
self.query_text.setStyleSheet("""QLineEdit {
background-color: LightGray;
color: white;
} """)
query_layout = QHBoxLayout()
query_layout.addWidget(self.query_label)
query_layout.addWidget(self.query_text)
self.select_label = QLabel("Select:")
self.select_all_button = QPushButton("All")
self.select_none_button = QPushButton("None")
self.select_invert_button = QPushButton("Invert")
self.delete_button = QPushButton("Delete Objects")
self.select_all_button.clicked.connect(self.select_all_clicked)
self.select_none_button.clicked.connect(self.select_none_clicked)
self.select_invert_button.clicked.connect(self.select_invert_clicked)
self.delete_button.clicked.connect(self.delete_button_clicked)
self.delete_button.setEnabled(False)
selection_layout = QHBoxLayout()
selection_layout.addWidget(self.select_label)
selection_layout.addWidget(self.select_all_button)
selection_layout.addWidget(self.select_none_button)
selection_layout.addWidget(self.select_invert_button)
selection_layout.addStretch()
selection_layout.addWidget(self.delete_button)
self.replace_with_text = QLineEdit()
self.replace_with_label = QLabel("Replace With:")
self.replace_button = QPushButton("Replace")
self.replace_button.clicked.connect(self.replace_button_clicked)
self.replace_button.setEnabled(False)
replace_layout = QHBoxLayout()
replace_layout.addWidget(self.replace_with_label)
replace_layout.addWidget(self.replace_with_text)
replace_layout.addWidget(self.replace_button)
layout = QVBoxLayout()
layout.addLayout(input_layout)
layout.addLayout(checks_layout)
layout.addLayout(query_layout)
layout.addWidget(self.results_tree)
layout.addLayout(selection_layout)
layout.addLayout(replace_layout)
self.resize(650, 450)
self.setLayout(layout)
self.setWindowTitle("IDF+ Search & Replace")
self.search_text.setFocus()
self.setTabOrder(self.search_text, self.search_button)
self.setTabOrder(self.search_button, self.whole_field_checkbox)
self.setTabOrder(self.whole_field_checkbox,
self.advanced_search_checkbox)
self.setTabOrder(self.advanced_search_checkbox, self.select_all_button)
self.setTabOrder(self.select_all_button, self.select_none_button)
self.setTabOrder(self.select_none_button, self.select_invert_button)
self.setTabOrder(self.select_invert_button, self.replace_with_text)
self.setTabOrder(self.replace_with_text, self.replace_button)
self.setTabOrder(self.replace_button, self.search_text)
self.results_tree.setModel(self.create_results_model([]))
self.results_tree.setColumnHidden(2, True)
if initial_query is not None:
self.search_text.setText(initial_query)
self.search_button.click()
def create_results_model(self, results):
def add_result_row(row_model, value, obj_class, uuid):
row_model.insertRow(0)
row_model.setData(model.index(0, 0), value)
row_model.setData(model.index(0, 1), obj_class)
row_model.setData(model.index(0, 2), uuid)
item_0 = model.itemFromIndex(model.index(0, 0))
item_0.setCheckState(Qt.Unchecked)
item_0.setFlags(item_0.flags() | Qt.ItemIsUserCheckable)
item_0.setEditable(False)
item_1 = model.itemFromIndex(model.index(0, 1))
item_1.setEditable(False)
model = QStandardItemModel(0, 3, self)
model.setHeaderData(0, Qt.Horizontal, "Value")
model.setHeaderData(1, Qt.Horizontal, "Class")
model.setHeaderData(2, Qt.Horizontal, "UUID")
for hit in results:
add_result_row(model, hit['value'], hit['obj_class_display'],
hit['uuid'])
return model
def submit_search(self):
"""Submits a search based on the current query
"""
user_query = self.search_text.text()
idf = self.parent.idf
if not user_query or len(user_query) < 2 or not idf:
return [], ""
results, my_query = idf.search(
user_query, self.whole_field_checkbox.isChecked(),
self.advanced_search_checkbox.isChecked(),
self.ignore_geometry_checkbox.isChecked())
self.query_text.setText(str(my_query))
self.results_tree.setModel(self.create_results_model(results))
self.results_tree.model().itemChanged.connect(self.item_checked)
# self.results_tree.setColumnHidden(2, True)
self.results_tree.resizeColumnToContents(0)
self.results_tree.resizeColumnToContents(1)
self.results_tree.setSortingEnabled(True)
def item_checked(self, item):
if item.checkState() == Qt.Checked:
self.items_checked += 1
else:
self.items_checked -= 1
if self.items_checked > 0:
self.delete_button.setEnabled(True)
self.replace_button.setEnabled(True)
else:
self.delete_button.setEnabled(False)
self.replace_button.setEnabled(False)
def select_all_clicked(self):
model = self.results_tree.model()
result_count = model.rowCount()
for i in range(result_count):
model.itemFromIndex(model.index(i, 0)).setCheckState(Qt.Checked)
def select_none_clicked(self):
model = self.results_tree.model()
result_count = model.rowCount()
for i in range(result_count):
model.itemFromIndex(model.index(i, 0)).setCheckState(Qt.Unchecked)
def select_invert_clicked(self):
model = self.results_tree.model()
result_count = model.rowCount()
for i in range(result_count):
item = model.itemFromIndex(model.index(i, 0))
if item.checkState() == Qt.Checked:
new_state = Qt.Unchecked
else:
new_state = Qt.Checked
item.setCheckState(new_state)
def delete_button_clicked(self):
model = self.results_tree.model()
result_count = model.rowCount()
if result_count <= 0 or self.items_checked <= 0:
return
question = "Are you sure you want to perform this deletion?\n" \
"Undo is currently NOT supported for this operation."
response = self.confirm_action(question)
if response is not True:
return
for i in range(result_count):
item_0 = model.itemFromIndex(model.index(i, 0))
item_2 = model.itemFromIndex(model.index(i, 2))
if item_0.checkState() != Qt.Checked:
continue
field = self.parent.idf.field_by_uuid(item_2.text())
obj = field._outer
obj_class = self.parent.idf.idf_objects(obj.obj_class)
try:
index = obj_class.index(obj)
self.parent.idf.remove_objects(obj.obj_class, index, index + 1)
except ValueError:
pass # already deleted
self.parent.set_dirty(True)
self.submit_search()
self.parent.load_table_view(self.parent.current_obj_class)
QMessageBox.information(self, "Delete Action", "Deletion Complete!")
def advanced_search_checked(self):
if self.advanced_search_checkbox.isChecked():
self.whole_field_checkbox.setEnabled(False)
self.whole_field_checkbox.setChecked(True)
self.ignore_geometry_checkbox.setEnabled(False)
self.ignore_geometry_checkbox.setChecked(False)
else:
self.whole_field_checkbox.setEnabled(True)
self.whole_field_checkbox.setChecked(False)
self.ignore_geometry_checkbox.setEnabled(True)
self.ignore_geometry_checkbox.setChecked(False)
def replace_button_clicked(self):
search_text = self.search_text.text()
replace_with_text = self.replace_with_text.text()
if not search_text:
return
model = self.results_tree.model()
result_count = model.rowCount()
if result_count <= 0 or self.items_checked <= 0:
return
question = "Are you sure you want to perform this replacement?\n" \
"Undo is currently NOT supported for this operation."
response = self.confirm_action(question)
if response is not True:
return
for i in range(result_count):
item_0 = model.itemFromIndex(model.index(i, 0))
item_2 = model.itemFromIndex(model.index(i, 2))
if item_0.checkState() != Qt.Checked:
continue
field = self.parent.idf.field_by_uuid(item_2.text())
if self.whole_field_checkbox.isChecked(
) or self.advanced_search_checkbox.isChecked():
field.value = replace_with_text
else:
regex = re.compile(re.escape(search_text), re.IGNORECASE)
field.value = regex.sub(replace_with_text, field.value)
self.parent.set_dirty(True)
self.submit_search()
self.parent.load_table_view(self.parent.current_obj_class)
QMessageBox.information(self, "Replacement", "Replacement Complete!")
def confirm_action(self, question):
"""Confirm user wants to perform action
"""
flags = QMessageBox.StandardButton.Yes
flags |= QMessageBox.StandardButton.No
response = QMessageBox.question(self, "Are you sure?", question, flags)
if response == QMessageBox.Yes:
return True
elif QMessageBox.No:
return False
else:
return False
def go_to_object(self, index=None):
if index is None:
selected = self.results_tree.selectedIndexes()
if not selected:
return
index = selected[0]
model = self.results_tree.model()
item = model.itemFromIndex(model.index(index.row(), 2))
field = self.parent.idf.field_by_uuid(item.text())
self.parent.activateWindow()
self.parent.jump_to_field(field)
