class SearchDialog(utils.Dialog):
def __init__(self, main_win, hex_widget):
utils.Dialog.__init__(self, main_win, name='search_dialog')
self.hexWidget = hex_widget
self.setWindowTitle(utils.tr('Search'))
self.m_layout = QVBoxLayout()
self.setLayout(self.m_layout)
self.descLabel = QLabel(self)
self.descLabel.setText(utils.tr('Enter hex values to search for:'))
self.m_layout.addWidget(self.descLabel)
self.hexInput = hexlineedit.HexLineEdit(self)
self.m_layout.addWidget(self.hexInput)
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.addButton(QDialogButtonBox.Close)
self.searchButton = QPushButton(utils.tr('Search'), self)
self.searchButton.setIcon(utils.getIcon('edit-find'))
self.buttonBox.addButton(self.searchButton, QDialogButtonBox.AcceptRole)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
self.m_layout.addWidget(self.buttonBox)
@property
def matcher(self):
return matchers.BinaryMatcher(self.hexWidget.document, self.hexInput.data)
def __init__(self, parent, url, archivo_destino):
super(Descargar, self).__init__(parent)
self.url = url
self.httpGetId = 0
self.httpRequestAborted = False
self.statusLabel = QLabel('Descargando el manual completo ...')
self.closeButton = QPushButton("Cerrar")
self.closeButton.setAutoDefault(False)
self.barra = QProgressBar()
buttonBox = QDialogButtonBox()
buttonBox.addButton(self.closeButton, QDialogButtonBox.RejectRole)
self.http = QHttp(self)
self.http.requestFinished.connect(self.cuando_finalizar_request)
self.http.dataReadProgress.connect(self.cuando_actualiza_descarga)
self.http.responseHeaderReceived.connect(self.cuando_responder_header)
self.closeButton.clicked.connect(self.cuando_cancela)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.statusLabel)
mainLayout.addWidget(self.barra)
mainLayout.addWidget(buttonBox)
self.setLayout(mainLayout)
self.setWindowTitle('Descargando manual')
self.downloadFile(url, archivo_destino)
def _create_buttons ( self, parent ):
buttons = QDialogButtonBox()
# 'OK' button.
# FIXME v3: Review how this is supposed to work for non-modal dialogs
# (ie. how does anything act on a button click?)
if self.ok_label:
btn = buttons.addButton( self.ok_label,
QDialogButtonBox.AcceptRole )
else:
btn = buttons.addButton( QDialogButtonBox.Ok )
btn.setDefault( True )
# 'Cancel' button.
# FIXME v3: Review how this is supposed to work for non-modal dialogs
# (ie. how does anything act on a button click?)
if self.cancel_label:
buttons.addButton( self.cancel_label, QDialogButtonBox.RejectRole )
else:
buttons.addButton( QDialogButtonBox.Cancel )
# 'Help' button.
# FIXME v3: In the original code the only possible hook into the help
# was to reimplement self._on_help(). However this was a private
# method. Obviously nobody uses the Help button. For the moment we
# display it but can't actually use it.
if len( self.help_id ) > 0:
if self.help_label:
buttons.addButton( self.help_label, QDialogButtonBox.HelpRole )
else:
buttons.addButton( QDialogButtonBox.Help )
return buttons
def fill(self):
# Vispa
# icon
# Version
# Release date os.path.getmtime(filename)
# website url
# license
self.setLayout(QVBoxLayout())
if "vispa" in self._application.windowTitle().lower():
self._logo = QSvgWidget(":/resources/vispa_logo.svg")
sizeHint = self._logo.sizeHint()
logo_width_height_ratio = 1.0 * sizeHint.width() / sizeHint.height()
logo_width = 200
self._logo.setFixedSize(logo_width, logo_width/logo_width_height_ratio)
self.layout().addWidget(self._logo)
else:
label=QLabel(self._application.windowTitle())
self.layout().addWidget(label)
self.layout().addWidget(QLabel("Version "+ self._application.version()))
self.layout().addWidget(QLabel("More information can be found on:"))
websiteLink = QLabel("<a href='"+ websiteUrl +"'>"+ websiteUrl +"</a>")
websiteLink.setTextInteractionFlags(Qt.LinksAccessibleByMouse | Qt.TextSelectableByMouse)
websiteLink.setOpenExternalLinks(True)
self.layout().addWidget(websiteLink)
buttonBox=QDialogButtonBox()
buttonBox.addButton(QDialogButtonBox.Close)
self.connect(buttonBox,SIGNAL("rejected()"),self,SLOT("reject()"))
self.layout().addWidget(buttonBox)
def addNodeList(self, key, predefs, selectednodes):
if not self.overwriteKeys(key) and type(key).__name__ == 'str':
layout = QVBoxLayout()
nodeList = NodeListItem()
nodeList.setDragDropMode(QAbstractItemView.InternalMove)
if len(predefs) > 0:
if not self.checkUnifiedTypes(predefs):
return -1
for predef in predefs:
nodeList.addSingleItem(str(predef), predef.value().uid())
if selectednodes and len(selectednodes) > 0:
for node in selectednodes:
name = QString.fromUtf8(node.absolute())
nodeList.addSingleItem(name, node.uid())
hbox = QHBoxLayout()
buttonbox = QDialogButtonBox()
add = NodeSelectionButton(self, key, nodeList)
buttonbox.addButton(add, QDialogButtonBox.ActionRole)
rm = rmLocalPathButton(self, nodeList)
buttonbox.addButton(rm, QDialogButtonBox.ActionRole)
self.connect(add, SIGNAL("clicked()"), self.argumentChanged)
self.connect(rm, SIGNAL("clicked()"), self.argumentChanged)
hbox.addWidget(buttonbox, 3, Qt.AlignLeft)
layout.addLayout(hbox, 0)
layout.addWidget(nodeList, 2)
if not self.displaykey:
self.layout.addRow(layout)
else:
self.layout.addRow(key, layout)
self.widgets[key] = nodeList
return 1
else:
return -1
def __init__(self, url_to_download, download_location, parent=None):
super(Downloader, self).__init__(parent)
self.httpGetId = 0
self.httpRequestAborted = False
self.statusLabel = QLabel('Downloading %s' % url_to_download)
self.closeButton = QPushButton("Close")
self.closeButton.setAutoDefault(False)
self.progressBar = QProgressBar()
buttonBox = QDialogButtonBox()
buttonBox.addButton(self.closeButton, QDialogButtonBox.RejectRole)
self.http = QHttp(self)
self.http.requestFinished.connect(self.httpRequestFinished)
self.http.dataReadProgress.connect(self.updateDataReadProgress)
self.http.responseHeaderReceived.connect(self.readResponseHeader)
self.closeButton.clicked.connect(self.cancelDownload)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.statusLabel)
mainLayout.addWidget(self.progressBar)
mainLayout.addWidget(buttonBox)
self.setLayout(mainLayout)
self.setWindowTitle('Downloader')
self.downloadFile(url_to_download, download_location)
class DialogStudentId(QDialog):
"""Dialog to change the student id.
Example (replace `parent` by the parent widget):
dialog = DialogStudentId(parent)
id = dialog.exec_()
"""
def __init__(self, parent, students):
super(DialogStudentId, self).__init__(parent)
self.setWindowTitle(_('Change the student id'))
layout = QFormLayout()
self.setLayout(layout)
self.combo = widgets.StudentComboBox(parent=self)
self.combo.add_students(students)
self.combo.editTextChanged.connect(self._check_value)
self.combo.currentIndexChanged.connect(self._check_value)
new_student_button = QPushButton( \
QIcon(utils.resource_path('new_id.svg')),
_('New student'), parent=self)
new_student_button.clicked.connect(self._new_student)
self.buttons = QDialogButtonBox((QDialogButtonBox.Ok
| QDialogButtonBox.Cancel))
self.buttons.addButton(new_student_button, QDialogButtonBox.ActionRole)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
layout.addRow(_('Student id:'), self.combo)
layout.addRow(self.buttons)
def exec_(self):
"""Shows the dialog and waits until it is closed.
Returns a student object with the option selected by the user.
The return value is None if the user cancels the dialog.
"""
result = super(DialogStudentId, self).exec_()
if result == QDialog.Accepted:
return self.combo.current_student()
else:
return None
def _new_student(self):
dialog = NewStudentDialog(parent=self)
student = dialog.exec_()
if student is not None:
self.combo.add_student(student, set_current=True)
self.buttons.button(QDialogButtonBox.Ok).setFocus()
self.buttons.button(QDialogButtonBox.Ok).setEnabled(True)
def _check_value(self, param):
if self.combo.current_student() is not None:
self.buttons.button(QDialogButtonBox.Ok).setEnabled(True)
else:
self.buttons.button(QDialogButtonBox.Ok).setEnabled(False)
def initUI(self):
u"""Build the dialog box."""
self.setWindowTitle(_(u'Anki – Download audio'))
self.setWindowIcon(QIcon(":/icons/anki.png"))
layout = QGridLayout()
self.setLayout(layout)
explanation = QLabel(self)
if len(self.entries_list) > 1:
explanation.setText(
_(u'Please select an action for each downloaded file:'))
else:
explanation.setText(_(u'Please select what to do with the file:'))
layout.addWidget(explanation, 0, 0, 1, self.num_columns)
if not self.hide_text:
text_head_label = QLabel(_(u'<b>Source text</b>'), self)
layout.addWidget(text_head_label, 1, 0, 1, 2)
text_head_label.setToolTip(self.text_help)
else:
text_head_label = QLabel(_(u'<b>Source</b>'), self)
layout.addWidget(text_head_label, 1, 0)
text_head_label.setToolTip(self.text_hide_help)
play_head_label = QLabel(_(u'play'), self)
play_head_label.setToolTip(self.play_help)
layout.addWidget(play_head_label, 1, self.play_column)
play_old_head_label = QLabel(_(u'play old'), self)
if not self.hide_text:
play_old_head_label.setToolTip(self.play_old_help)
else:
play_old_head_label.setToolTip(self.play_old_hide_help)
layout.addWidget(play_old_head_label, 1, self.play_old_column)
add_head_label = QLabel(_(u'add'), self)
add_head_label.setToolTip(self.add_help_text_long)
layout.addWidget(add_head_label, 1, self.add_column)
keep_head_label = QLabel(_(u'keep'), self)
keep_head_label.setToolTip(self.keep_help_text_long)
layout.addWidget(keep_head_label, 1, self.keep_column)
delete_head_label = QLabel(_(u'delete'), self)
delete_head_label.setToolTip(self.delete_help_text_long)
layout.addWidget(delete_head_label, 1, self.delete_column)
if self.show_skull_and_bones:
blacklist_head_label = QLabel(_(u'blacklist'), self)
blacklist_head_label.setToolTip(self.blacklist_help_text_long)
layout.addWidget(blacklist_head_label, 1, self.blacklist_column)
rule_label = QLabel('<hr>')
layout.addWidget(rule_label, 2, 0, 1, self.num_columns)
self.create_rows(layout)
dialog_buttons = QDialogButtonBox(self)
dialog_buttons.addButton(QDialogButtonBox.Cancel)
dialog_buttons.addButton(QDialogButtonBox.Ok)
self.connect(
dialog_buttons, SIGNAL("accepted()"), self, SLOT("accept()"))
self.connect(
dialog_buttons, SIGNAL("rejected()"), self, SLOT("reject()"))
layout.addWidget(
dialog_buttons, len(self.buttons_groups) + 3, 0, 1,
self.num_columns)
class DialogStudentId(QDialog):
"""Dialog to change the student id.
Example (replace `parent` by the parent widget):
dialog = DialogStudentId(parent)
id = dialog.exec_()
"""
def __init__(self, parent, students):
super(DialogStudentId, self).__init__(parent)
self.setWindowTitle(_('Change the student id'))
layout = QFormLayout()
self.setLayout(layout)
self.combo = widgets.StudentComboBox(parent=self)
self.combo.add_students(students)
self.combo.editTextChanged.connect(self._check_value)
self.combo.currentIndexChanged.connect(self._check_value)
new_student_button = QPushButton( \
QIcon(utils.resource_path('new_id.svg')),
_('New student'), parent=self)
new_student_button.clicked.connect(self._new_student)
self.buttons = QDialogButtonBox((QDialogButtonBox.Ok
| QDialogButtonBox.Cancel))
self.buttons.addButton(new_student_button, QDialogButtonBox.ActionRole)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
layout.addRow(_('Student id:'), self.combo)
layout.addRow(self.buttons)
def exec_(self):
"""Shows the dialog and waits until it is closed.
Returns a student object with the option selected by the user.
The return value is None if the user cancels the dialog.
"""
result = super(DialogStudentId, self).exec_()
if result == QDialog.Accepted:
return self.combo.current_student()
else:
return None
def _new_student(self):
dialog = NewStudentDialog(parent=self)
student = dialog.exec_()
if student is not None:
self.combo.add_student(student, set_current=True)
self.buttons.button(QDialogButtonBox.Ok).setFocus()
self.buttons.button(QDialogButtonBox.Ok).setEnabled(True)
def _check_value(self, param):
if self.combo.current_student() is not None:
self.buttons.button(QDialogButtonBox.Ok).setEnabled(True)
else:
self.buttons.button(QDialogButtonBox.Ok).setEnabled(False)
class DeletionOptions(QDialog):
def __init__(self, parent, model):
flags = Qt.CustomizeWindowHint | Qt.WindowTitleHint | Qt.WindowSystemMenuHint
QDialog.__init__(self, parent, flags)
self.model = model
self._setupUi()
self.model.view = self
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
def _setupUi(self):
self.setWindowTitle(tr("Deletion Options"))
self.resize(400, 270)
self.verticalLayout = QVBoxLayout(self)
self.msgLabel = QLabel()
self.verticalLayout.addWidget(self.msgLabel)
self.linkCheckbox = QCheckBox(tr("Link deleted files"))
self.verticalLayout.addWidget(self.linkCheckbox)
text = tr("After having deleted a duplicate, place a link targeting the reference file "
"to replace the deleted file.")
self.linkMessageLabel = QLabel(text)
self.linkMessageLabel.setWordWrap(True)
self.verticalLayout.addWidget(self.linkMessageLabel)
self.linkTypeRadio = RadioBox(items=[tr("Symlink"), tr("Hardlink")], spread=False)
self.verticalLayout.addWidget(self.linkTypeRadio)
if not self.model.supports_links():
self.linkCheckbox.setEnabled(False)
self.linkTypeRadio.setEnabled(False)
self.linkCheckbox.setText(self.linkCheckbox.text() + tr(" (unsupported)"))
self.directCheckbox = QCheckBox(tr("Directly delete files"))
self.verticalLayout.addWidget(self.directCheckbox)
text = tr("Instead of sending files to trash, delete them directly. This option is usually "
"used as a workaround when the normal deletion method doesn't work.")
self.directMessageLabel = QLabel(text)
self.directMessageLabel.setWordWrap(True)
self.verticalLayout.addWidget(self.directMessageLabel)
self.buttonBox = QDialogButtonBox()
self.buttonBox.addButton(tr("Proceed"), QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(tr("Cancel"), QDialogButtonBox.RejectRole)
self.verticalLayout.addWidget(self.buttonBox)
#--- model --> view
def update_msg(self, msg):
self.msgLabel.setText(msg)
def show(self):
self.linkCheckbox.setChecked(self.model.link_deleted)
self.linkTypeRadio.selected_index = 1 if self.model.use_hardlinks else 0
self.directCheckbox.setChecked(self.model.direct)
result = self.exec()
self.model.link_deleted = self.linkCheckbox.isChecked()
self.model.use_hardlinks = self.linkTypeRadio.selected_index == 1
self.model.direct = self.directCheckbox.isChecked()
return result == QDialog.Accepted
def initUI(self):
u"""Build the dialog box."""
self.setWindowTitle(_(u'Anki – Download audio'))
self.setWindowIcon(QIcon(":/icons/anki.png"))
layout = QGridLayout()
self.setLayout(layout)
explanation = QLabel(self)
if len(self.list) > 1:
explanation.setText(
_(u'Please select an action for each downloaded file:'))
else:
explanation.setText(_(u'Please select what to do with the file:'))
layout.addWidget(explanation, 0, 0, 1, self.num_columns)
if not self.hide_text:
text_head_label = QLabel(_(u'<b>Source text</b>'), self)
layout.addWidget(text_head_label, 1, 0, 1, 2)
text_head_label.setToolTip(self.text_help)
else:
text_head_label = QLabel(_(u'<b>Source</b>'), self)
layout.addWidget(text_head_label, 1, 0)
text_head_label.setToolTip(self.text_hide_help)
play_head_label = QLabel(_(u'play'), self)
play_head_label.setToolTip(self.play_help)
layout.addWidget(play_head_label, 1, self.play_column)
play_old_head_label = QLabel(_(u'play old'), self)
if not self.hide_text:
play_old_head_label.setToolTip(self.play_old_help)
else:
play_old_head_label.setToolTip(self.play_old_hide_help)
layout.addWidget(play_old_head_label, 1, self.play_old_column)
add_head_label = QLabel(_(u'add'), self)
add_head_label.setToolTip(self.add_help_text_long)
layout.addWidget(add_head_label, 1, self.add_column)
keep_head_label = QLabel(_(u'keep'), self)
keep_head_label.setToolTip(self.keep_help_text_long)
layout.addWidget(keep_head_label, 1, self.keep_column)
delete_head_label = QLabel(_(u'delete'), self)
delete_head_label.setToolTip(self.delete_help_text_long)
layout.addWidget(delete_head_label, 1, self.delete_column)
if self.show_skull_and_bones:
blacklist_head_label = QLabel(_(u'blacklist'), self)
blacklist_head_label.setToolTip(self.blacklist_help_text_long)
layout.addWidget(blacklist_head_label, 1, self.blacklist_column)
rule_label = QLabel('<hr>')
layout.addWidget(rule_label, 2, 0, 1, self.num_columns)
self.create_rows(layout)
dialog_buttons = QDialogButtonBox(self)
dialog_buttons.addButton(QDialogButtonBox.Cancel)
dialog_buttons.addButton(QDialogButtonBox.Ok)
self.connect(dialog_buttons, SIGNAL("accepted()"),
self, SLOT("accept()"))
self.connect(dialog_buttons, SIGNAL("rejected()"),
self, SLOT("reject()"))
layout.addWidget(dialog_buttons,
len(self.buttons_groups) + 3, 0, 1, self.num_columns)
def _initButtonBox(self):
cancelButton = QPushButton("Deny", self)
cancelButton.clicked.connect(self.reject)
okButton = QPushButton("Accept", self)
okButton.clicked.connect(self.accept)
buttonBox = QDialogButtonBox(Qt.Horizontal, self)
buttonBox.addButton(cancelButton, QDialogButtonBox.RejectRole)
buttonBox.addButton(okButton, QDialogButtonBox.AcceptRole)
return buttonBox
def __init__(self, parent = None):
LoginDialog.__init__(self, parent)
buttonBox = QDialogButtonBox()
buttonBox.addButton(QDialogButtonBox.Ok)
buttonBox.addButton(QDialogButtonBox.Cancel)
buttonBox.accepted.connect(self.checkInput)
buttonBox.rejected.connect(self.reject)
self.layout().addRow(buttonBox)
def manage_buttons(self):
buttons = QDialogButtonBox(Qt.Horizontal, self)
button_cancel = QPushButton("&Anuluj")
button_replace = QPushButton("&Zast\u0105p")
button_compare = QPushButton("&Por\u00F3wnaj")
buttons.addButton(button_cancel, QDialogButtonBox.RejectRole)
buttons.addButton(button_replace, QDialogButtonBox.AcceptRole)
buttons.addButton(button_compare, QDialogButtonBox.AcceptRole)
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)
button_compare.clicked.connect(self.compare)
self.layout.addWidget(buttons, 1, 3)
def addPathList(self, key, typeid, predefs, selectednodes):
if not self.overwriteKeys(key) and type(key).__name__=='str':
layout = QVBoxLayout()
listpathcontainer = QListWidget() ##XXX
listpathcontainer.setDragDropMode(QAbstractItemView.InternalMove)
if len(predefs) > 0:
if not self.checkUnifiedTypes(predefs):
return -1
for predef in predefs:
listpathcontainer.insertItem(listpathcontainer.count() + 1, str(predef))
if selectednodes and len(selectednodes) > 0:
for node in selectednodes:
if type(node) == Node and typeid == typeId.Node:
listpathcontainer.insertItem(listpathcontainer.count() + 1, QString.fromUtf8(node.absolute()))
elif type(node) != Node:
listpathcontainer.insertItem(listpathcontainer.count() + 1, node)
hbox = QHBoxLayout()
buttonbox = QDialogButtonBox()
if typeid == typeId.Path:
combo = QComboBox()
self.connect(combo, SIGNAL("editTextChanged(QString)"), self.argumentChanged)
self.connect(combo, SIGNAL("currentIndexChanged(QString)"), self.argumentChanged)
combo.addItem(self.inputFile)
combo.addItem(self.inputDirectory)
add = addLocalPathButton(self, key, listpathcontainer, combo)
else:
add = addLocalPathButton(self, key, listpathcontainer, nodetype=True)
buttonbox.addButton(add, QDialogButtonBox.ActionRole)
rm = rmLocalPathButton(self, listpathcontainer)
buttonbox.addButton(rm, QDialogButtonBox.ActionRole)
self.connect(add, SIGNAL("clicked()"), self.argumentChanged)
self.connect(rm, SIGNAL("clicked()"), self.argumentChanged)
hbox.addWidget(buttonbox, 3, Qt.AlignLeft)
if typeid == typeId.Path:
hbox.addWidget(combo, 1, Qt.AlignRight)
layout.addLayout(hbox, 0)
layout.addWidget(listpathcontainer, 2)
if not self.displaykey:
self.layout.addRow(layout)
else:
self.layout.addRow(key, layout)
self.widgets[key] = listpathcontainer
return 1
else:
return -1
def __init__(self, data, title="", comment="",
icon=None, parent=None, apply=None):
super(FormDialog, self).__init__(parent)
self.apply_callback = apply
# Form
if isinstance(data[0][0], (list, tuple)):
self.formwidget = FormTabWidget(data, comment=comment,
parent=self)
elif len(data[0])==3:
self.formwidget = FormComboWidget(data, comment=comment,
parent=self)
else:
self.formwidget = FormWidget(data, comment=comment,
parent=self)
layout = QVBoxLayout()
layout.addWidget(self.formwidget)
# Button box
bbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
if self.apply_callback is not None:
apply_btn = bbox.addButton(QDialogButtonBox.Apply)
self.connect(apply_btn, SIGNAL("clicked()"), self.apply)
self.connect(bbox, SIGNAL("accepted()"), SLOT("accept()"))
self.connect(bbox, SIGNAL("rejected()"), SLOT("reject()"))
layout.addWidget(bbox)
self.setLayout(layout)
self.setWindowTitle(title)
if not isinstance(icon, QIcon):
icon = QWidget().style().standardIcon(QStyle.SP_MessageBoxQuestion)
self.setWindowIcon(icon)
def __init__(self, data, title="", comment="",
icon=None, parent=None, apply=None):
super(FormDialog, self).__init__(parent)
self.apply_callback = apply
# Form
if isinstance(data[0][0], (list, tuple)):
self.formwidget = FormTabWidget(data, comment=comment,
parent=self)
elif len(data[0])==3:
self.formwidget = FormComboWidget(data, comment=comment,
parent=self)
else:
self.formwidget = FormWidget(data, comment=comment,
parent=self)
layout = QVBoxLayout()
layout.addWidget(self.formwidget)
# Button box
bbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
if self.apply_callback is not None:
apply_btn = bbox.addButton(QDialogButtonBox.Apply)
self.connect(apply_btn, SIGNAL("clicked()"), self.apply)
self.connect(bbox, SIGNAL("accepted()"), SLOT("accept()"))
self.connect(bbox, SIGNAL("rejected()"), SLOT("reject()"))
layout.addWidget(bbox)
self.setLayout(layout)
self.setWindowTitle(title)
if not isinstance(icon, QIcon):
icon = QWidget().style().standardIcon(QStyle.SP_MessageBoxQuestion)
self.setWindowIcon(icon)
class AboutDialog(QDialog):
"""
Common About Dialog for the Freeseer Project. This should be used for the
about dialog when including one in GUIs.
Grid Layout:
Logo | About Infos
------|-------------
| Close Button
"""
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.aboutWidget = AboutWidget()
icon = QIcon()
icon.addPixmap(QPixmap(_fromUtf8(":/freeseer/logo.png")), QIcon.Normal, QIcon.Off)
self.setWindowIcon(icon)
self.layout = QGridLayout()
self.setLayout(self.layout)
self.layout.addWidget(self.aboutWidget)
# Right Bottom corner of grid, Close Button
self.buttonBox = QDialogButtonBox()
self.closeButton = self.buttonBox.addButton("Close", QDialogButtonBox.AcceptRole)
self.layout.addWidget(self.buttonBox, 1, 1)
self.connect(self.closeButton, SIGNAL("clicked()"), self.close)
self.setWindowTitle("About Freeseer")
def __init__(self):
super(ForceUpgradeDialog, self).__init__()
vbox = QVBoxLayout(self)
self.setWindowTitle(u"El contenido debe actualizarse")
self.main_text = QLabel(UPGRADE_TEXT)
vbox.addWidget(self.main_text)
bbox = QDialogButtonBox()
bbox.addButton(QPushButton(u"Salir del programa"),
QDialogButtonBox.AcceptRole)
bbox.accepted.connect(self.accept)
bbox.addButton(QPushButton(u"Continuar"), QDialogButtonBox.RejectRole)
bbox.rejected.connect(self.reject)
vbox.addWidget(bbox)
self.show()
def __init__(self, parent=None):
super(MusicPreviewDialog, self).__init__(parent)
layout = QVBoxLayout()
self.setLayout(layout)
self._widget = MusicPreviewWidget()
layout.addWidget(self._widget)
layout.addWidget(widgets.Separator())
b = QDialogButtonBox()
layout.addWidget(b)
b.addButton(QDialogButtonBox.Close)
b.rejected.connect(self.accept)
self._printButton = b.addButton('', QDialogButtonBox.ActionRole)
self._printButton.setIcon(icons.get("document-print"))
self._printButton.clicked.connect(self._widget.print_)
self._printButton.hide()
qutil.saveDialogSize(self, "musicpreview/dialog/size", QSize(500, 350))
app.translateUI(self)
def __init__(self, parent=None):
super(MusicPreviewDialog, self).__init__(parent)
layout = QVBoxLayout()
self.setLayout(layout)
self._widget = MusicPreviewWidget()
layout.addWidget(self._widget)
layout.addWidget(widgets.Separator())
b = QDialogButtonBox()
layout.addWidget(b)
b.addButton(QDialogButtonBox.Close)
b.rejected.connect(self.accept)
self._printButton = b.addButton('', QDialogButtonBox.ActionRole)
self._printButton.setIcon(icons.get("document-print"))
self._printButton.clicked.connect(self._widget.print_)
self._printButton.hide()
qutil.saveDialogSize(self, "musicpreview/dialog/size", QSize(500, 350))
app.translateUI(self)
def __init__(self, parent, description = "Please enter your login information:", loginText = "Login:"******"Password:"):
QDialog.__init__(self, parent)
self._username = None
self._password = None
formGridLayout = QGridLayout(self)
descLabel = QLabel(description, self)
descLabel.setWordWrap(True)
descLabel.setContentsMargins(0,0,0,5)
self.editUserName = QLineEdit(self)
self.editPassword = QLineEdit(self)
self.editPassword.setEchoMode( QLineEdit.Password )
labelUsername = QLabel(self)
labelPassword = QLabel(self)
labelUsername.setText(loginText)
labelUsername.setBuddy(self.editUserName)
labelPassword.setText(passwordText)
labelPassword.setBuddy(self.editPassword)
buttons = QDialogButtonBox(self)
buttons.addButton(QDialogButtonBox.Ok)
buttons.addButton(QDialogButtonBox.Cancel)
buttons.button(QDialogButtonBox.Cancel).clicked.connect(self.close)
buttons.button(QDialogButtonBox.Ok).clicked.connect(self.slotAcceptLogin)
formGridLayout.addWidget(descLabel, 0, 0, 1, 2)
formGridLayout.addWidget(labelUsername, 1, 0, 1, 1, Qt.AlignRight)
formGridLayout.addWidget(self.editUserName, 1, 1)
formGridLayout.addWidget(labelPassword, 2, 0, 1, 1, Qt.AlignRight)
formGridLayout.addWidget(self.editPassword, 2, 1)
formGridLayout.addWidget(buttons, 3, 0, 1, 2, Qt.AlignBottom)
formGridLayout.setRowStretch(0, 0)
formGridLayout.setRowStretch(1, 0)
formGridLayout.setRowStretch(2, 0)
formGridLayout.setRowStretch(3, 1)
self.setMaximumHeight(self.sizeHint().height())
self.setMinimumHeight(self.sizeHint().height())
#self.setMinimumWidth(400)
self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
def __init__(self):
super(ForceUpgradeDialog, self).__init__()
vbox = QVBoxLayout(self)
self.setWindowTitle(u"El contenido debe actualizarse")
self.main_text = QLabel(UPGRADE_TEXT)
vbox.addWidget(self.main_text)
bbox = QDialogButtonBox()
bbox.addButton(QPushButton(u"Salir del programa"),
QDialogButtonBox.AcceptRole)
bbox.accepted.connect(self.accept)
bbox.addButton(QPushButton(u"Continuar"),
QDialogButtonBox.RejectRole)
bbox.rejected.connect(self.reject)
vbox.addWidget(bbox)
self.show()
def __init__(self, parent):
super(LunchinatorSettingsDialog, self).__init__(parent, Qt.Dialog)
self.setWindowTitle("Lunchinator Settings")
# self.setModal(True)
self.setResult(QDialog.Rejected)
contentLayout = QVBoxLayout(self)
self.nb = ComboTabWidget(self)
self.nb.setTabPosition(QTabWidget.North)
self.widget_containers = {}
self.widget_names = []
try:
if get_settings().get_plugins_enabled():
for pluginInfo in get_plugin_manager().getAllPlugins():
if pluginInfo.plugin_object.is_activated:
self.addPlugin(pluginInfo.plugin_object, pluginInfo.name, pluginInfo.category)
except:
getCoreLogger().exception("while including plugins in settings window")
contentLayout.addWidget(self.nb)
# d.get_content_area().pack_start(nb, True, True, 0)
if self.nb.count() > 0:
self.nb.setCurrentIndex(0)
# show first widget
self.nb.widget(0).showContents()
buttonBox = QDialogButtonBox(Qt.Horizontal, self)
saveButton = QPushButton("Save", self)
# saveButton.setAutoDefault(True)
saveButton.clicked.connect(self.savePressed)
buttonBox.addButton(saveButton, QDialogButtonBox.AcceptRole)
cancelButton = QPushButton("Cancel", self)
cancelButton.clicked.connect(self.cancelPressed)
buttonBox.addButton(cancelButton, QDialogButtonBox.RejectRole)
applyButton = QPushButton("Apply", self)
applyButton.clicked.connect(self.applyPressed)
buttonBox.addButton(applyButton, QDialogButtonBox.ApplyRole)
discardButton = QPushButton("Discard", self)
discardButton.clicked.connect(self.discardPressed)
buttonBox.addButton(discardButton, QDialogButtonBox.ApplyRole)
contentLayout.addWidget(buttonBox)
get_notification_center().connectPluginActivated(self._pluginActivated)
get_notification_center().connectPluginWillBeDeactivated(self._pluginWillBeDeactivated)
def __init__(self, widget, parent = None):
QDialog.__init__(self, parent)
# We keep a reference to the widget in the form.
self.widget = widget
try:
self.type = type(widget.paramDefault).__name__
except AttributeError:
try:
self.type = type(widget.paramMin).__name__
except AttributeError:
self.type = "Bang"
self.address = QLineEdit(self)
self.address.setText(widget.paramPath)
self.address.setSelection(0, self.address.maxLength())
self.default = [None for i in range(self.widget.length)]
self.max = [None for i in range(self.widget.length)]
self.min = [None for i in range(self.widget.length)]
self.standardActions = [None for i in range(self.widget.length)]
self.setupAtoms()
self.setValues()
buttonBox = QDialogButtonBox()
okButton = buttonBox.addButton(buttonBox.Ok)
cancelButton = buttonBox.addButton(buttonBox.Cancel)
self.connect(okButton, SIGNAL("clicked()"),
self.updateWidget)
self.connect(cancelButton, SIGNAL("clicked()"),
self, SLOT("reject()"))
layout = QVBoxLayout()
layout.addWidget(QLabel("OSC Path", self))
layout.addWidget(self.address)
self.setupAtomUi(layout)
layout.addWidget(buttonBox)
self.setLayout(layout)
self.setWindowTitle(self.tr("Edit Malarm Properties"))
def add_button_box(self, stdbtns):
"""Create dialog button box and add it to the dialog layout"""
bbox = QDialogButtonBox(stdbtns)
run_btn = bbox.addButton(_("Run"), QDialogButtonBox.AcceptRole)
self.connect(run_btn, SIGNAL('clicked()'), self.run_btn_clicked)
self.connect(bbox, SIGNAL("accepted()"), SLOT("accept()"))
self.connect(bbox, SIGNAL("rejected()"), SLOT("reject()"))
btnlayout = QHBoxLayout()
btnlayout.addStretch(1)
btnlayout.addWidget(bbox)
self.layout().addLayout(btnlayout)
def add_button_box(self, stdbtns):
"""Create dialog button box and add it to the dialog layout"""
bbox = QDialogButtonBox(stdbtns)
run_btn = bbox.addButton(_("Run"), QDialogButtonBox.AcceptRole)
self.connect(run_btn, SIGNAL('clicked()'), self.run_btn_clicked)
self.connect(bbox, SIGNAL("accepted()"), SLOT("accept()"))
self.connect(bbox, SIGNAL("rejected()"), SLOT("reject()"))
btnlayout = QHBoxLayout()
btnlayout.addStretch(1)
btnlayout.addWidget(bbox)
self.layout().addLayout(btnlayout)
def widget(self,parent):
td = ListPickerDialog(self, parent)
td.setWindowTitle("Select Server")
td.setAttribute(Qt.WA_DeleteOnClose)
layout = QHBoxLayout();
layout.setContentsMargins(16, 0, 16, 8)
view = self.view()
if not view:
listView = QListView()
listView.setEditTriggers( QAbstractItemView.NoEditTriggers)
listView.setModel(self.model())
listView.setModelColumn(self.modelColumn())
if listView.sizeHintForRow(0)>0:
listView.setMinimumHeight(listView.sizeHintForRow(0) * 5)
view = listView
else:
view.setModel(self.model())
layout.addWidget(view)
self.setView(view)
if self.model():
index = self.model().index(self.currentIndex(), self.modelColumn())
self.selectModelIndex(index)
btnbox = QDialogButtonBox(Qt.Vertical)
btnbox.addButton("Select", QDialogButtonBox.AcceptRole)
addBtn = btnbox.addButton("Add", QDialogButtonBox.ActionRole)
addBtn.clicked.connect(self.addServer)
editBtn = btnbox.addButton("Edit", QDialogButtonBox.ActionRole)
editBtn.clicked.connect(self.editServer)
remBtn = btnbox.addButton("Remove", QDialogButtonBox.ActionRole)
remBtn.clicked.connect(self.remServer)
btnbox.accepted.connect( td.accept)
btnbox.rejected.connect( td.reject)
layout.addWidget(btnbox)
td.setLayout(layout)
return td
def __init__(self, main_window):
super(WizardDialog, self).__init__()
self.mw = main_window
vbox = QVBoxLayout(self)
# label and checkbox
self.main_text = QLabel(u"init text")
vbox.addWidget(self.main_text)
self.notthisagain = QCheckBox(u"No mostrar automáticamente esta ayuda")
nowizard = config.get('nowizard', False)
self.notthisagain.setCheckState(nowizard)
self.notthisagain.stateChanged.connect(self._notthisagain_toggled)
vbox.addWidget(self.notthisagain)
# buttons
bbox = QDialogButtonBox()
self.navbut_actn = QPushButton(u"init text")
bbox.addButton(self.navbut_actn, QDialogButtonBox.ActionRole)
self.navbut_prev = QPushButton(u"Anterior")
bbox.addButton(self.navbut_prev, QDialogButtonBox.ActionRole)
self.navbut_next = QPushButton(u"Siguiente")
bbox.addButton(self.navbut_next, QDialogButtonBox.ActionRole)
vbox.addWidget(bbox)
self.show()
self.step = 0
self._move(0)
def __init__(self, main_window):
super(WizardDialog, self).__init__()
self.mw = main_window
vbox = QVBoxLayout(self)
# label and checkbox
self.main_text = QLabel(u"init text")
vbox.addWidget(self.main_text)
self.notthisagain = QCheckBox(u"No mostrar automáticamente esta ayuda")
nowizard = config.get('nowizard', False)
self.notthisagain.setCheckState(nowizard)
self.notthisagain.stateChanged.connect(self._notthisagain_toggled)
vbox.addWidget(self.notthisagain)
# buttons
bbox = QDialogButtonBox()
self.navbut_actn = QPushButton(u"init text")
bbox.addButton(self.navbut_actn, QDialogButtonBox.ActionRole)
self.navbut_prev = QPushButton(u"Anterior")
bbox.addButton(self.navbut_prev, QDialogButtonBox.ActionRole)
self.navbut_next = QPushButton(u"Siguiente")
bbox.addButton(self.navbut_next, QDialogButtonBox.ActionRole)
vbox.addWidget(bbox)
self.show()
self.step = 0
self._move(0)
def __init__(self, client):
super(TableList, self).__init__(None)
self.autoStarted = False
self.client = client
self.setObjectName('TableList')
self.resize(700, 400)
self.view = MJTableView(self)
self.differ = None
self.debugModelTest = None
self.requestedNewTable = False
self.view.setItemDelegateForColumn(2,
RichTextColumnDelegate(self.view))
buttonBox = QDialogButtonBox(self)
self.newButton = buttonBox.addButton(
m18nc('allocate a new table', "&New"), QDialogButtonBox.ActionRole)
self.newButton.setIcon(KIcon("document-new"))
self.newButton.setToolTip(m18n("Allocate a new table"))
self.newButton.clicked.connect(self.client.newTable)
self.joinButton = buttonBox.addButton(m18n("&Join"),
QDialogButtonBox.AcceptRole)
self.joinButton.clicked.connect(client.joinTable)
self.joinButton.setIcon(KIcon("list-add-user"))
self.joinButton.setToolTip(m18n("Join a table"))
self.leaveButton = buttonBox.addButton(m18n("&Leave"),
QDialogButtonBox.AcceptRole)
self.leaveButton.clicked.connect(self.leaveTable)
self.leaveButton.setIcon(KIcon("list-remove-user"))
self.leaveButton.setToolTip(m18n("Leave a table"))
self.compareButton = buttonBox.addButton(
m18nc('Kajongg-Ruleset', 'Compare'), QDialogButtonBox.AcceptRole)
self.compareButton.clicked.connect(self.compareRuleset)
self.compareButton.setIcon(KIcon("preferences-plugin-script"))
self.compareButton.setToolTip(
m18n('Compare the rules of this table with my own rulesets'))
self.chatButton = buttonBox.addButton(m18n('&Chat'),
QDialogButtonBox.AcceptRole)
self.chatButton.setIcon(KIcon("call-start"))
self.chatButton.clicked.connect(self.chat)
self.startButton = buttonBox.addButton(m18n('&Start'),
QDialogButtonBox.AcceptRole)
self.startButton.clicked.connect(self.startGame)
self.startButton.setIcon(KIcon("arrow-right"))
self.startButton.setToolTip(
m18n(
"Start playing on a table. Empty seats will be taken by robot players."
))
cmdLayout = QHBoxLayout()
cmdLayout.addWidget(buttonBox)
layout = QVBoxLayout()
layout.addWidget(self.view)
layout.addLayout(cmdLayout)
self.setLayout(layout)
self.view.doubleClicked.connect(client.joinTable)
StateSaver(self, self.view.horizontalHeader())
self.updateButtonsForTable(None)
def _create_buttons ( self, dialog, layout ):
""" Creates the buttons.
"""
# Create the button:
buttons = QDialogButtonBox()
if self.can_cancel:
buttons.addButton( self.cancel_button_label,
QDialogButtonBox.RejectRole )
buttons.addButton( QDialogButtonBox.Ok )
# TODO: hookup the buttons to our methods, this may involve subclassing
# from QDialog
if self.can_cancel:
buttons.connect( buttons, SIGNAL( 'rejected()' ), dialog,
SLOT( 'reject() ' ) )
buttons.connect( buttons, SIGNAL( 'accepted()' ), dialog,
SLOT( 'accept()' ) )
layout.addWidget( buttons )
def addPathList(self, key, predefs):
if not self.overwriteKeys(key) and type(key).__name__ == 'str':
layout = QVBoxLayout()
pathList = ListItem() ##XXX
pathList.setDragDropMode(QAbstractItemView.InternalMove)
if len(predefs) > 0:
if not self.checkUnifiedTypes(predefs):
return -1
for predef in predefs:
pathList.addSingleItem(str(predef))
hbox = QHBoxLayout()
buttonbox = QDialogButtonBox()
combo = QComboBox()
combo.setMinimumContentsLength(20)
self.connect(combo, SIGNAL("editTextChanged(QString)"),
self.argumentChanged)
self.connect(combo, SIGNAL("currentIndexChanged(QString)"),
self.argumentChanged)
combo.addItem(self.inputFile)
combo.addItem(self.inputDirectory)
add = PathSelectionButton(self, key, pathList, combo)
buttonbox.addButton(add, QDialogButtonBox.ActionRole)
rm = rmLocalPathButton(self, pathList)
buttonbox.addButton(rm, QDialogButtonBox.ActionRole)
self.connect(add, SIGNAL("clicked()"), self.argumentChanged)
self.connect(rm, SIGNAL("clicked()"), self.argumentChanged)
hbox.addWidget(buttonbox, 3, Qt.AlignLeft)
hbox.addWidget(combo, 1, Qt.AlignRight)
layout.addLayout(hbox, 0)
layout.addWidget(pathList, 2)
if not self.displaykey:
self.layout.addRow(layout)
else:
self.layout.addRow(key, layout)
self.widgets[key] = pathList
return 1
else:
return -1
class UnlockTalkWidget(QDialog):
def __init__(self, parent=None):
super(UnlockTalkWidget, self).__init__(parent)
self.setWindowTitle('Unlock Talk Details')
self.layout = QVBoxLayout()
self.setLayout(self.layout)
self.information = QLabel('Enter the password to unlock the talks')
self.layout.addWidget(self.information)
self.passwordBox = QLineEdit()
self.layout.addWidget(self.passwordBox)
self.buttonBox = QDialogButtonBox(Qt.Horizontal)
self.layout.addWidget(self.buttonBox)
self.unlockButton = QPushButton('Unlock')
self.cancelButton = QPushButton('Cancel')
self.buttonBox.addButton(self.unlockButton,
QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(self.cancelButton,
QDialogButtonBox.RejectRole)
def __init__(self, parent=None, url_to_download=None, fout=None):
" init class "
super(Downloader, self).__init__(parent)
self.timer = time()
self.httpGetId = 0
self.httpRequestAborted = False
self.url = QUrl(url_to_download)
self.fileInfo = QFileInfo(self.url.path())
self.fout = fout
self.fileName = path.join(fout, str(self.fileInfo.fileName()))
self.statusLabel = QLabel(
"<center><h3>Downloading from:</h3>%s<h3>Saving to:</h3>%s</center>" % (url_to_download, fout)
)
self.bytes = QLabel(" ??? ")
self.closeButton = QPushButton(" Cancel ")
self.closeButton.setAutoDefault(False)
self.progressBar = QProgressBar()
buttonBox = QDialogButtonBox()
buttonBox.addButton(self.closeButton, QDialogButtonBox.RejectRole)
self.http = QHttp(self)
self.http.requestFinished.connect(self.httpRequestFinished)
self.http.dataReadProgress.connect(self.updateDataReadProgress)
self.http.responseHeaderReceived.connect(self.readResponseHeader)
self.closeButton.clicked.connect(self.cancelDownload)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.statusLabel)
mainLayout.addWidget(self.progressBar)
mainLayout.addWidget(self.bytes)
mainLayout.addWidget(buttonBox)
self.setLayout(mainLayout)
self.setWindowTitle(__doc__ + " - MultiThreaded Downloader ")
self.resize(parent.size().width(), self.size().height())
self.downloadFile(url_to_download, fout)
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 UnlockTalkWidget(QDialog):
def __init__(self, parent=None):
super(UnlockTalkWidget, self).__init__(parent)
self.setWindowTitle('Unlock Talk Details')
self.layout = QVBoxLayout()
self.setLayout(self.layout)
self.information = QLabel('Enter the password to unlock the talks')
self.layout.addWidget(self.information)
self.passwordBox = QLineEdit()
self.layout.addWidget(self.passwordBox)
self.buttonBox = QDialogButtonBox(Qt.Horizontal)
self.layout.addWidget(self.buttonBox)
self.unlockButton = QPushButton('Unlock')
self.cancelButton = QPushButton('Cancel')
self.buttonBox.addButton(
self.unlockButton, QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(
self.cancelButton, QDialogButtonBox.RejectRole)
def __createLayout( self ):
""" Creates the dialog layout """
self.resize( 400, 100 )
self.setSizeGripEnabled( True )
verticalLayout = QVBoxLayout( self )
# Check boxes
self.includeClassesBox = QCheckBox( self )
self.includeClassesBox.setText( "Show &classes in modules" )
self.includeClassesBox.setChecked( self.options.includeClasses )
self.includeClassesBox.stateChanged.connect( self.__updateOptions )
self.includeFuncsBox = QCheckBox( self )
self.includeFuncsBox.setText( "Show &functions in modules" )
self.includeFuncsBox.setChecked( self.options.includeFuncs )
self.includeFuncsBox.stateChanged.connect( self.__updateOptions )
self.includeGlobsBox = QCheckBox( self )
self.includeGlobsBox.setText( "Show &global variables in modules" )
self.includeGlobsBox.setChecked( self.options.includeGlobs )
self.includeGlobsBox.stateChanged.connect( self.__updateOptions )
self.includeDocsBox = QCheckBox( self )
self.includeDocsBox.setText( "Show modules &docstrings" )
self.includeDocsBox.setChecked( self.options.includeDocs )
self.includeDocsBox.stateChanged.connect( self.__updateOptions )
self.includeConnTextBox = QCheckBox( self )
self.includeConnTextBox.setText( "Show connection &labels" )
self.includeConnTextBox.setChecked( self.options.includeConnText )
self.includeConnTextBox.stateChanged.connect( self.__updateOptions )
verticalLayout.addWidget( self.includeClassesBox )
verticalLayout.addWidget( self.includeFuncsBox )
verticalLayout.addWidget( self.includeGlobsBox )
verticalLayout.addWidget( self.includeDocsBox )
verticalLayout.addWidget( self.includeConnTextBox )
# Buttons at the bottom
buttonBox = QDialogButtonBox( self )
buttonBox.setOrientation( Qt.Horizontal )
buttonBox.setStandardButtons( QDialogButtonBox.Cancel )
generateButton = buttonBox.addButton( "Generate",
QDialogButtonBox.ActionRole )
generateButton.setDefault( True )
generateButton.clicked.connect( self.accept )
verticalLayout.addWidget( buttonBox )
buttonBox.rejected.connect( self.close )
return
def __init__(self, client):
super(TableList, self).__init__(None)
self.autoStarted = False
self.client = client
self.setObjectName('TableList')
self.resize(700, 400)
self.view = MJTableView(self)
self.differ = None
self.debugModelTest = None
self.requestedNewTable = False
self.view.setItemDelegateForColumn(2, RichTextColumnDelegate(self.view))
buttonBox = QDialogButtonBox(self)
self.newButton = buttonBox.addButton(m18nc('allocate a new table', "&New"), QDialogButtonBox.ActionRole)
self.newButton.setIcon(KIcon("document-new"))
self.newButton.setToolTip(m18n("Allocate a new table"))
self.newButton.clicked.connect(self.client.newTable)
self.joinButton = buttonBox.addButton(m18n("&Join"), QDialogButtonBox.AcceptRole)
self.joinButton.clicked.connect(client.joinTable)
self.joinButton.setIcon(KIcon("list-add-user"))
self.joinButton.setToolTip(m18n("Join a table"))
self.leaveButton = buttonBox.addButton(m18n("&Leave"), QDialogButtonBox.AcceptRole)
self.leaveButton.clicked.connect(self.leaveTable)
self.leaveButton.setIcon(KIcon("list-remove-user"))
self.leaveButton.setToolTip(m18n("Leave a table"))
self.compareButton = buttonBox.addButton(m18nc('Kajongg-Ruleset','Compare'), QDialogButtonBox.AcceptRole)
self.compareButton.clicked.connect(self.compareRuleset)
self.compareButton.setIcon(KIcon("preferences-plugin-script"))
self.compareButton.setToolTip(m18n('Compare the rules of this table with my own rulesets'))
self.chatButton = buttonBox.addButton(m18n('&Chat'), QDialogButtonBox.AcceptRole)
self.chatButton.setIcon(KIcon("call-start"))
self.chatButton.clicked.connect(self.chat)
self.startButton = buttonBox.addButton(m18n('&Start'), QDialogButtonBox.AcceptRole)
self.startButton.clicked.connect(self.startGame)
self.startButton.setIcon(KIcon("arrow-right"))
self.startButton.setToolTip(m18n("Start playing on a table. Empty seats will be taken by robot players."))
cmdLayout = QHBoxLayout()
cmdLayout.addWidget(buttonBox)
layout = QVBoxLayout()
layout.addWidget(self.view)
layout.addLayout(cmdLayout)
self.setLayout(layout)
self.view.doubleClicked.connect(client.joinTable)
StateSaver(self, self.view.horizontalHeader())
self.updateButtonsForTable(None)
def _initUI(self, text):
layout = QVBoxLayout(self)
layout.setContentsMargins(0, 10, 0, 0)
layout.setSpacing(5)
labelLayout = QHBoxLayout()
if not text:
text = u"Some plugins cannot be activated due to missing requirements:"
label = QLabel(text, self)
label.setWordWrap(True)
labelLayout.addWidget(label)
labelLayout.setContentsMargins(10, 0, 0, 0)
layout.addLayout(labelLayout)
self._reqTable = QTreeWidget(self)
self._reqTable.setSortingEnabled(False)
self._reqTable.setHeaderHidden(False)
self._reqTable.setAlternatingRowColors(True)
self._reqTable.setIndentation(0)
self._reqTable.setUniformRowHeights(True)
self._reqTable.setObjectName(u"__ERROR_LOG_")
self._reqTable.setColumnCount(3)
self._reqTable.setHeaderLabels([u"Package", u"Problem", u"Required by"])
self._reqTable.setFrameShape(QFrame.StyledPanel)
if getPlatform() == PLATFORM_MAC:
self._reqTable.setAttribute(Qt.WA_MacShowFocusRect, False)
self._reqTable.setStyleSheet("QFrame#__ERROR_LOG_{border-width: 1px; border-top-style: solid; border-right-style: none; border-bottom-style: solid; border-left-style: none; border-color:palette(mid)}");
layout.addWidget(self._reqTable)
buttonBox = QDialogButtonBox(Qt.Horizontal, self)
ignore = QPushButton(u"Ignore", self)
deactivate = QPushButton(u"Deactivate", self)
install = QPushButton(u"Install Selected", self)
install.setEnabled(self._canInstall)
buttonBox.addButton(deactivate, QDialogButtonBox.DestructiveRole)
buttonBox.addButton(ignore, QDialogButtonBox.RejectRole)
buttonBox.addButton(install, QDialogButtonBox.AcceptRole)
deactivate.clicked.connect(self._deactivate)
ignore.clicked.connect(self._ignore)
buttonBox.accepted.connect(self.accept)
bottomLayout = QHBoxLayout()
bottomLayout.addWidget(buttonBox, 1, Qt.AlignRight)
layout.addLayout(bottomLayout)
class ConfirmationDialog(QDialog):
def __init__(self, parent = None):
QDialog.__init__(self, parent)
save = QPushButton(self.trUtf8('&Save'))
save.clicked.connect(self.close)
close = QPushButton(self.trUtf8('Close &without saving'))
close.clicked.connect(self.close)
cancel = QPushButton(self.trUtf8('&Cancel'))
cancel.clicked.connect(self.close)
self.buttons = QDialogButtonBox()
self.buttons.addButton(save, QDialogButtonBox.AcceptRole)
self.buttons.addButton(close, QDialogButtonBox.HelpRole)
self.buttons.addButton(cancel, QDialogButtonBox.RejectRole)
label = QLabel(self.trUtf8(
"You've got some unsaved changes. What would you like to do?"))
layout = QVBoxLayout()
layout.addWidget(label)
layout.addWidget(self.buttons)
self.setLayout(layout)
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 _QueuedMessageWidget(QWidget):
cleared = pyqtSignal()
finished = pyqtSignal()
shown = pyqtSignal()
closed = pyqtSignal()
linkActivated = pyqtSignal(unicode)
linkHovered= pyqtSignal(unicode)
buttonClicked = pyqtSignal(QAbstractButton)
def __init__(self, *args):
QWidget.__init__(self, *args)
self._messages = []
self._defaultTimeout = 0
self._defaultPixmap = QPixmap(":/enkiicons/infos.png" )
self._defaultBackground = QBrush( QColor( 250, 230, 147 ) )
self._defaultForeground = QBrush( QColor( 0, 0, 0 ) )
# pixmap
self.lPixmap = QLabel( self )
self.lPixmap.setAlignment( Qt.AlignCenter )
self.lPixmap.setSizePolicy( QSizePolicy( QSizePolicy.Maximum, QSizePolicy.Preferred ) )
# message
self.lMessage = QLabel( self )
self.lMessage.setAlignment( Qt.AlignVCenter | Qt.AlignLeft )
self.lMessage.setSizePolicy( QSizePolicy( QSizePolicy.Expanding, QSizePolicy.Preferred ) )
self.lMessage.setWordWrap( True )
self.lMessage.setOpenExternalLinks( True )
self.lMessage.setTextInteractionFlags( Qt.TextBrowserInteraction )
# button
self.dbbButtons = QDialogButtonBox( self )
# if false - buttons don't have neither text nor icons
self.dbbButtons.setStyleSheet("dialogbuttonbox-buttons-have-icons: true;")
self.dbbButtons.setSizePolicy( QSizePolicy( QSizePolicy.Maximum, QSizePolicy.Preferred ) )
self.setSizePolicy( QSizePolicy( QSizePolicy.Expanding, QSizePolicy.Maximum ) )
# layout
self.hbl = QHBoxLayout( self )
self.hbl.setMargin( 0 )
self.hbl.addWidget( self.lPixmap, 0, Qt.AlignCenter )
self.hbl.addWidget( self.lMessage )
self.hbl.addWidget( self.dbbButtons, 0, Qt.AlignCenter )
# connections
self.lMessage.linkActivated.connect(self.linkActivated)
self.lMessage.linkHovered.connect(self.linkHovered)
self.dbbButtons.clicked.connect(self.buttonClicked)
def sizeHint(self):
return QWidget.minimumSizeHint(self)
def openExternalLinks(self):
return self.lMessage.openExternalLinks()
def defaultTimeout(self):
return self._defaultTimeout
def defaultPixmap(self):
return self._defaultPixmap
def defaultBackground(self):
return self._defaultBackground
def defaultForeground(self):
return self._defaultForeground
def currentMessageInformations(self):
return self.currentMessagePixmap(), self.currentMessageBackground(), self.currentMessageForeground()
def pendingMessageCount(self):
return len(self._messages)
def currentMessage(self):
return self._messages[0]
def append(self, message, milliSeconds ):
msg = _QueuedMessage()
msg.message = message
if milliSeconds == -1:
msg.milliSeconds = self._defaultTimeout
else:
msg.milliSeconds = milliSeconds
msg.pixmap = self._defaultPixmap
msg.background = self._defaultBackground
msg.foreground = self._defaultForeground
self._messages.append(msg)
if len(self._messages) == 1 :
QTimer.singleShot( 0, self.showMessage)
def setOpenExternalLinks(self, open ):
self.lMessage.setOpenExternalLinks( open )
def setDefaultTimeout(self, timeout ):
self._defaultTimeout = timeout
def setDefaultPixmap(self, pixmap ):
self._defaultPixmap = pixmap
def setDefaultBackground(self, brush ):
self._defaultBackground = brush
def setDefaultForeground(self, brush ):
self._defaultForeground = brush
def remove(self, message ):
raise NotImplemented() # incorrect port from cpp fresh
if not self._messages or self._messages.first() == message:
return
self._messages.removeOne( message )
def clear(self):
self._messages.clear()
self.lPixmap.clear()
self.lMessage.clear()
self.dbbButtons.clear()
self.cleared.emit()
def currentMessagePixmap(self):
msg = self.currentMessage()
if msg.pixmap.isNull():
return self._defaultPixmap
else:
return msg.pixmap
def currentMessageBackground(self):
msg = self.currentMessage()
if msg.background == QBrush( Qt.NoBrush ):
return self._defaultBackground
else:
return msg.background
def currentMessageForeground(self):
msg = self.currentMessage()
if msg.foreground == QBrush( Qt.NoBrush ):
return self._defaultForeground
else:
return msg.foreground
def paintEvent(self, event ):
if self.pendingMessageCount() == 0 :
QWidget.paintEvent(self, event )
return
painter = QPainter( self )
painter.setPen( Qt.NoPen )
painter.setBrush( self.currentMessageBackground() )
painter.drawRect( self.contentsRect() )
def buttonClicked(self, button ):
msg = self.currentMessage()
standardButton = self.dbbButtons.standardButton( button )
if msg.slot is not None:
msg.slot(standardButton, msg)
self.closeMessage()
def showMessage(self):
# get message
msg = self.currentMessage()
# update palette
pal = self.lMessage.palette()
pal.setBrush( self.lMessage.foregroundRole(), self.currentMessageForeground() )
self.lMessage.setPalette( pal )
# format widget
self.lPixmap.setPixmap( self.currentMessagePixmap() )
self.lMessage.setText( msg.message )
self.lMessage.setToolTip( msg.message )
self.lMessage.setWhatsThis( msg.message )
# set buttons
if not msg.buttons:
msg.buttons[ QDialogButtonBox.Close ] = None
self.dbbButtons.clear()
for button in msg.buttons.keys():
pb = self.dbbButtons.addButton( button )
if button in msg.buttons:
pb.setText( msg.buttons[ button ] )
# auto close if needed
if msg.milliSeconds == -1:
timeout = self._defaultTimeout
else:
timeout = msg.milliSeconds
if timeout > 0:
QTimer.singleShot( timeout, self.closeMessage )
# signal.emit
self.shown.emit()
def closeMessage(self):
# message.emit
self.closed.emit()
# remove remove current message from hash
self._messages = self._messages[1:]
# process next if possible, clear gui
if self._messages:
QTimer.singleShot( 0, self.showMessage)
else:
QTimer.singleShot( 0, self.clearMessage)
# finished.emit message if needed
if not self._messages:
self.finished.emit()
def clearMessage(self):
self.lPixmap.clear()
self.lMessage.clear()
self.dbbButtons.clear()
class DeletionOptions(QDialog):
def __init__(self, parent, model):
flags = Qt.CustomizeWindowHint | Qt.WindowTitleHint | Qt.WindowSystemMenuHint
QDialog.__init__(self, parent, flags)
self.model = model
self._setupUi()
self.model.view = self
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
def _setupUi(self):
self.setWindowTitle(tr("Deletion Options"))
self.resize(400, 270)
self.verticalLayout = QVBoxLayout(self)
self.msgLabel = QLabel()
self.verticalLayout.addWidget(self.msgLabel)
self.linkCheckbox = QCheckBox(tr("Link deleted files"))
self.verticalLayout.addWidget(self.linkCheckbox)
text = tr(
"After having deleted a duplicate, place a link targeting the reference file "
"to replace the deleted file.")
self.linkMessageLabel = QLabel(text)
self.linkMessageLabel.setWordWrap(True)
self.verticalLayout.addWidget(self.linkMessageLabel)
self.linkTypeRadio = RadioBox(items=[tr("Symlink"),
tr("Hardlink")],
spread=False)
self.verticalLayout.addWidget(self.linkTypeRadio)
if not self.model.supports_links():
self.linkCheckbox.setEnabled(False)
self.linkTypeRadio.setEnabled(False)
self.linkCheckbox.setText(self.linkCheckbox.text() +
tr(" (unsupported)"))
self.directCheckbox = QCheckBox(tr("Directly delete files"))
self.verticalLayout.addWidget(self.directCheckbox)
text = tr(
"Instead of sending files to trash, delete them directly. This option is usually "
"used as a workaround when the normal deletion method doesn't work."
)
self.directMessageLabel = QLabel(text)
self.directMessageLabel.setWordWrap(True)
self.verticalLayout.addWidget(self.directMessageLabel)
self.buttonBox = QDialogButtonBox()
self.buttonBox.addButton(tr("Proceed"), QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(tr("Cancel"), QDialogButtonBox.RejectRole)
self.verticalLayout.addWidget(self.buttonBox)
#--- model --> view
def update_msg(self, msg):
self.msgLabel.setText(msg)
def show(self):
self.linkCheckbox.setChecked(self.model.link_deleted)
self.linkTypeRadio.selected_index = 1 if self.model.use_hardlinks else 0
self.directCheckbox.setChecked(self.model.direct)
result = self.exec()
self.model.link_deleted = self.linkCheckbox.isChecked()
self.model.use_hardlinks = self.linkTypeRadio.selected_index == 1
self.model.direct = self.directCheckbox.isChecked()
return result == QDialog.Accepted
class MainWidget(QMainWindow):
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.configOptions, self.checkBoxList, self.configBool = {}, {}, None
# Check for root privileges
if geteuid() != 0:
msg = ("{} is not root. You need to run with root priviliges\n"
"Please use kdesudo, gksu or sudo/sux.").format(getuser())
QMessageBox.critical(self, __doc__ + "- Error", msg)
sys.exit(1)
else:
msg = "This tool is running with root priviliges."
QMessageBox.warning(self, __doc__ + "- Warning", msg)
# title, icon and sizes
self.setWindowTitle(__doc__)
self.setMinimumSize(400, 400)
self.setMaximumSize(2048, 2048)
self.resize(600, 600)
self.setWindowIcon(QIcon.fromTheme("preferences-system"))
self.menuBar().addMenu("&File").addAction("Exit", exit)
QShortcut("Ctrl+q", self, activated=lambda: self.close())
# main group
main_group = QGroupBox("Module configuration")
self.setCentralWidget(main_group)
self.layout = QVBoxLayout(main_group)
# scrollarea widgets
self.scrollArea, self.window = QScrollArea(), QWidget()
self.layout.addWidget(self.scrollArea)
self.vbox = QVBoxLayout(self.window)
# Graphic effect
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
self.scrollArea.setGraphicsEffect(glow)
glow.setEnabled(True)
# config loading stuff
self.findConfig(CONFIG_DIR)
for eachOption in tuple(self.configOptions.keys()):
self.readConfig(eachOption, self.configOptions)
self.subLayout = QHBoxLayout()
self.checkBoxName = "checkBox_" + eachOption
checkBoxList = QCheckBox(self.checkBoxName, self)
self.checkBoxList[self.checkBoxName] = checkBoxList
checkBoxList.setObjectName(self.checkBoxName)
checkBoxList.setText("Enable module {}".format(eachOption))
if self.tooltip is not '':
checkBoxList.setToolTip(self.tooltip)
else:
tooltip = "Configuration settings for {}".format(eachOption)
checkBoxList.setToolTip(tooltip)
if self.configBool:
checkBoxList.setChecked(True)
self.subLayout.addWidget(checkBoxList)
self.vbox.addLayout(self.subLayout)
self.scrollArea.setWidget(self.window)
# Bottom Buttons Bar
self.pushButtonSleep = QPushButton("Sleep")
self.pushButtonSleep.setToolTip("Trigger Suspend to RAM aka Sleep")
self.pushButtonSleep.clicked.connect(self.sleep)
self.pushButtonHibernate = QPushButton("Hibernate")
self.pushButtonHibernate.setToolTip(
"Trigger Suspend to Disk Hibernate")
self.pushButtonHibernate.clicked.connect(self.hibernate)
self.buttonBox = QDialogButtonBox()
self.buttonBox.setStandardButtons(QDialogButtonBox.Ok
| QDialogButtonBox.Close
| QDialogButtonBox.Help)
self.buttonBox.addButton(self.pushButtonHibernate,
QDialogButtonBox.ActionRole)
self.buttonBox.addButton(self.pushButtonSleep,
QDialogButtonBox.ActionRole)
self.layout.addWidget(self.buttonBox)
self.buttonBox.rejected.connect(exit)
self.buttonBox.accepted.connect(self.writeConfig)
self.buttonBox.helpRequested.connect(lambda: open_new_tab(WEBPAGE_URL))
def closeEvent(self, event):
' Ask to Quit '
the_conditional_is_true = QMessageBox.question(
self, __doc__.title(), 'Quit ?.', QMessageBox.Yes | QMessageBox.No,
QMessageBox.No) == QMessageBox.Yes
event.accept() if the_conditional_is_true else event.ignore()
def sleep(self):
"""Method to make the computer Sleep."""
try:
sysfsFP = open("/sys/power/state", 'w')
except:
log.err("Couldn't open kernel interface")
return False
else:
try:
sysfsFP.write("mem")
except:
log.err("Couldn't write to kernel interface")
return False
def hibernate(self):
"""Method to make the computer Hibernate."""
try:
sysfsFP = open("/sys/power/state", 'w')
except:
log.err("Couldn't open kernel interface")
return False
else:
try:
sysfsFP.write("disk")
except:
log.err("Couldn't write to kernel interface")
return False
def writeConfig(self):
"""Method to get a configuration for the App."""
finalResult = True
for eachWriteOption in tuple(self.configOptions.keys()):
checkBoxName = "checkBox_" + eachWriteOption
if self.checkBoxList[checkBoxName].isChecked() is True:
val = 1
else:
val = 0
ret = self.populateValues(self.configOptions[eachWriteOption], val)
if ret is False:
log.debug("Couldn't apply setting for %s" % checkBoxName)
finalResult = False
if finalResult is False:
QMessageBox.critical(self, "Error",
"Couldn't apply all requested settings")
else:
QMessageBox.information(self, "Success",
"Applied all requested settings")
def populateValues(self, _path, value):
"""Method to populate values from a file path."""
try:
readHandle = open(_path, 'r')
writeHandle = open(_path + ".tmp", 'w')
for line in readHandle.readlines():
if line.startswith(CONTROL_IDENTIFIER):
newline = line.split("=")[0] + "=" + str(value)
writeHandle.write(newline)
# You need this newline, otherwise the next line gets
# overlapped here
writeHandle.write("\n")
else:
writeHandle.write(line)
readHandle.close()
writeHandle.close()
move(_path + ".tmp", _path)
return True
except:
log.debug("Failed in populateValues() when operating on %s" %
_path)
return False
def findConfig(self, configDir):
"""Take a configDir and find the configuration for the App."""
if configDir is None:
return False
# TODO: Do we need to take care of the vendor specific overrides ???
for configFile in listdir(configDir):
if access(path.join(configDir, configFile), F_OK) is True:
fn = path.join(configDir, configFile)
self.configOptions[configFile.split(".")[0]] = fn
else:
pass
def readConfig(self, key, configOptionsDict):
"""Take a key and dict and read the configurations for the App."""
self.tooltip = ''
if key is None or configOptionsDict is None:
return False
try:
fileHandle = open(configOptionsDict[key], 'r')
except:
return False
for line in fileHandle.readlines():
if line.startswith(COMMENT_IDENTIFIER):
self.tooltip = self.tooltip + line.lstrip(COMMENT_IDENTIFIER)
elif line.startswith(CONTROL_IDENTIFIER):
boolValue = line.split("=")[1]
# Bloody boolValue could inherit the '\n' new line
boolValue = boolValue.rstrip("\n")
if boolValue == str(1) or "\"auto\"" in boolValue:
self.configBool = True
else:
self.configBool = False
# This will ensure that even if we don't read any string, tooltip
# doesn't fail
self.tooltip = self.tooltip + ''
class QgsTextAnnotationDialog(QDialog):
def __init__(self, item):
QDialog.__init__(self)
self.gridLayout = QGridLayout(self)
self.gridLayout.setObjectName(("gridLayout"))
self.horizontalLayout = QHBoxLayout()
self.horizontalLayout.setObjectName(("horizontalLayout"))
self.mFontComboBox = QFontComboBox(self)
self.mFontComboBox.setObjectName(("mFontComboBox"))
self.horizontalLayout.addWidget(self.mFontComboBox)
spacerItem = QSpacerItem(38, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
self.horizontalLayout.addItem(spacerItem)
self.mFontSizeSpinBox = QSpinBox(self)
self.mFontSizeSpinBox.setObjectName(("mFontSizeSpinBox"))
self.horizontalLayout.addWidget(self.mFontSizeSpinBox)
self.mBoldPushButton = QPushButton(self)
self.mBoldPushButton.setMinimumSize(QSize(50, 0))
self.mBoldPushButton.setCheckable(True)
self.mBoldPushButton.setObjectName(("mBoldPushButton"))
self.horizontalLayout.addWidget(self.mBoldPushButton)
self.mItalicsPushButton = QPushButton(self)
self.mItalicsPushButton.setMinimumSize(QSize(50, 0))
self.mItalicsPushButton.setCheckable(True)
self.mItalicsPushButton.setObjectName(("mItalicsPushButton"))
self.horizontalLayout.addWidget(self.mItalicsPushButton)
self.mFontColorButton = QgsColorButton(self)
self.mFontColorButton.setText((""))
self.mFontColorButton.setAutoDefault(False)
self.mFontColorButton.setObjectName(("mFontColorButton"))
self.horizontalLayout.addWidget(self.mFontColorButton)
self.gridLayout.addLayout(self.horizontalLayout, 0, 0, 1, 1)
self.mButtonBox = QDialogButtonBox(self)
self.mButtonBox.setOrientation(Qt.Horizontal)
self.mButtonBox.setStandardButtons(QDialogButtonBox.Cancel|QDialogButtonBox.Ok)
self.mButtonBox.setObjectName(("mButtonBox"))
self.gridLayout.addWidget(self.mButtonBox, 3, 0, 1, 1)
self.mTextEdit = QTextEdit(self)
self.mTextEdit.setObjectName(("mTextEdit"))
self.gridLayout.addWidget(self.mTextEdit, 1, 0, 1, 1)
self.mStackedWidget = QStackedWidget(self)
self.mStackedWidget.setObjectName(("mStackedWidget"))
self.page = QWidget()
self.page.setObjectName(("page"))
self.mStackedWidget.addWidget(self.page)
self.page_2 = QWidget()
self.page_2.setObjectName(("page_2"))
self.mStackedWidget.addWidget(self.page_2)
self.gridLayout.addWidget(self.mStackedWidget, 2, 0, 1, 1)
self.setLayout(self.gridLayout)
self.mStackedWidget.setCurrentIndex(0)
QObject.connect(self.mButtonBox, SIGNAL(("accepted()")), self.accept)
QObject.connect(self.mButtonBox, SIGNAL(("rejected()")), self.reject)
self.setTabOrder(self.mFontComboBox, self.mFontSizeSpinBox)
self.setTabOrder(self.mFontSizeSpinBox, self.mBoldPushButton)
self.setTabOrder(self.mBoldPushButton, self.mItalicsPushButton)
self.setTabOrder(self.mItalicsPushButton, self.mFontColorButton)
self.setTabOrder(self.mFontColorButton, self.mTextEdit)
self.setTabOrder(self.mTextEdit, self.mButtonBox)
self.setWindowTitle("Annotation text")
self.mBoldPushButton.setText("B")
self.mItalicsPushButton.setText("I")
self.mTextDocument = None
self.mItem = item
self.mEmbeddedWidget = QgsAnnotationWidget(self, self.mItem )
self.mEmbeddedWidget.show()
self.mStackedWidget.addWidget( self.mEmbeddedWidget )
self.mStackedWidget.setCurrentWidget( self.mEmbeddedWidget )
if ( self.mItem != None ):
self.mTextDocument = self.mItem.document()
self.mTextEdit.setDocument( self.mTextDocument )
self.mFontColorButton.setColorDialogTitle( "Select font color" )
self.mFontColorButton.setColorDialogOptions( QColorDialog.ShowAlphaChannel )
self.setCurrentFontPropertiesToGui()
QObject.connect( self.mButtonBox, SIGNAL("accepted()"), self.applyTextToItem)
# QObject.connect( self.mFontComboBox, SIGNAL( "currentFontChanged(QFont())"), self.changeCurrentFormat)
self.mFontComboBox.currentFontChanged.connect(self.changeCurrentFormat)
QObject.connect( self.mFontSizeSpinBox, SIGNAL( "valueChanged( int )" ), self.changeCurrentFormat )
QObject.connect( self.mBoldPushButton, SIGNAL( "toggled( bool )" ), self.changeCurrentFormat)
QObject.connect( self.mItalicsPushButton, SIGNAL( "toggled( bool )" ), self.changeCurrentFormat)
QObject.connect( self.mTextEdit, SIGNAL( "cursorPositionChanged()" ), self.setCurrentFontPropertiesToGui )
# QObject.connect( self.mButtonBox, SIGNAL( "accepted()" ), self.applySettingsToItem)
deleteButton = QPushButton( "Delete" )
QObject.connect( deleteButton, SIGNAL( "clicked()" ), self.deleteItem )
self.mButtonBox.addButton( deleteButton, QDialogButtonBox.RejectRole )
def applyTextToItem(self):
if ( self.mItem != None and self.mTextDocument !=None ):
if ( self.mEmbeddedWidget != None):
self.mEmbeddedWidget.apply()
self.mItem.setDocument( self.mTextDocument )
self.mItem.update()
def changeCurrentFormat(self):
newFont = QFont()
newFont.setFamily( self.mFontComboBox.currentFont().family() )
#bold
if ( self.mBoldPushButton.isChecked() ):
newFont.setBold( True )
else:
newFont.setBold( False )
#italic
if ( self.mItalicsPushButton.isChecked() ):
newFont.setItalic( True )
else:
newFont.setItalic( False )
#size
newFont.setPointSize( self.mFontSizeSpinBox.value() )
self.mTextEdit.setCurrentFont( newFont )
#color
self.mTextEdit.setTextColor( self.mFontColorButton.color() )
def on_mFontColorButton_colorChanged(self, color ):
self.changeCurrentFormat()
def setCurrentFontPropertiesToGui(self):
self.blockAllSignals( True )
currentFont = self.mTextEdit.currentFont()
self.mFontComboBox.setCurrentFont( currentFont )
self.mFontSizeSpinBox.setValue( currentFont.pointSize() )
self.mBoldPushButton.setChecked( currentFont.bold() )
self.mItalicsPushButton.setChecked( currentFont.italic() )
self.mFontColorButton.setColor( self.mTextEdit.textColor() )
self.blockAllSignals( False )
def blockAllSignals(self, block ):
self.mFontComboBox.blockSignals( block )
self.mFontSizeSpinBox.blockSignals( block )
self.mBoldPushButton.blockSignals( block )
self.mItalicsPushButton.blockSignals( block )
self.mFontColorButton.blockSignals( block )
def deleteItem(self):
scene = self.mItem.scene()
if ( scene != None ):
scene.removeItem( self.mItem )
self.mItem = None
class EntityEditorDialog(QDialog, MapperMixin):
"""
Dialog for editing entity attributes.
"""
addedModel = pyqtSignal(object)
def __init__(self,
entity,
model=None,
parent=None,
manage_documents=True,
collect_model=False,
parent_entity=None,
exclude_columns=[],
plugin=None):
"""
Class constructor.
:param entity: Entity object corresponding to a table object.
:type entity: Entity
:param model: Data object for loading data into the form widgets.
If the model is set, then the editor dialog is assumed to be in edit
mode.
:type model: object
:param parent: Parent widget that the form belongs to.
:type parent: QWidget
:param manage_documents: True if the dialog should provide controls
for managing supporting documents. Only applicable if the entity
allows for supporting documents to be attached.
:type manage_documents: bool
:param collect_model: If set to True only returns
the filled form model without saving it to the database.
:type collect_model: Boolean
:param parent_entity: The parent entity of the editor
:type parent_entity: Object
:param exclude_columns: List of columns to be excluded if in a list.
:type exclude_columns: List
:return: If collect_model, returns SQLAlchemy Model
"""
QDialog.__init__(self, parent)
self.entity_table_model = {}
self.collection_suffix = self.tr('Collection')
#Set minimum width
self.setMinimumWidth(450)
self.plugin = plugin
#Flag for mandatory columns
self.has_mandatory = False
self.reload_form = False
self._entity = entity
self.edit_model = model
self.column_widgets = OrderedDict()
self._parent = parent
self.exclude_columns = exclude_columns
self.entity_tab_widget = None
self._disable_collections = False
self.filter_val = None
self.parent_entity = parent_entity
self.child_models = OrderedDict()
self.entity_scroll_area = None
self.entity_editor_widgets = OrderedDict()
# Set notification layout bar
self.vlNotification = QVBoxLayout()
self.vlNotification.setObjectName('vlNotification')
self._notifBar = NotificationBar(self.vlNotification)
self.do_not_check_dirty = False
# Set manage documents only if the entity supports documents
if self._entity.supports_documents:
self._manage_documents = manage_documents
else:
self._manage_documents = False
# Setup entity model
self._ent_document_model = None
if self._entity.supports_documents:
self.ent_model, self._ent_document_model = entity_model(
self._entity, with_supporting_document=True)
else:
self.ent_model = entity_model(self._entity)
if not model is None:
self.ent_model = model
MapperMixin.__init__(self, self.ent_model, entity)
self.collect_model = collect_model
self.register_column_widgets()
try:
if isinstance(parent._parent, EntityEditorDialog):
# hide collections form child editor
self._disable_collections = True
except AttributeError:
self._parent._parent = None
# Set title
editor_trans = self.tr('Editor')
if self._entity.label is not None:
if self._entity.label != '':
title_str = self._entity.label
else:
title_str = format_name(self._entity.short_name)
else:
title_str = format_name(self._entity.short_name)
self.title = u'{0} {1}'.format(title_str, editor_trans)
self.setWindowTitle(self.title)
self._init_gui()
self.adjustSize()
self._get_entity_editor_widgets()
if isinstance(parent._parent, EntityEditorDialog):
self.parent_entity = parent.parent_entity
self.set_parent_values()
# make the size smaller to differentiate from parent and as it
# only has few tabs.
self.adjustSize()
self.attribute_mappers = self._attr_mapper_collection
# Exception title for editor extension exceptions
self._ext_exc_msg = self.tr(
'An error has occured while executing Python code in the editor '
'extension:')
# Register custom editor extension if specified
self._editor_ext = entity_dlg_extension(self)
if not self._editor_ext is None:
self._editor_ext.post_init()
# Initialize CascadingFieldContext objects
self._editor_ext.connect_cf_contexts()
def _init_gui(self):
# Setup base elements
self.gridLayout = QGridLayout(self)
self.gridLayout.setObjectName('glMain')
self.gridLayout.addLayout(self.vlNotification, 0, 0, 1, 1)
QApplication.processEvents()
#set widgets values
column_widget_area = self._setup_columns_content_area()
self.gridLayout.addWidget(column_widget_area, 1, 0, 1, 1)
QApplication.processEvents()
# Add notification for mandatory columns if applicable
next_row = 2
if self.has_mandatory:
self.required_fields_lbl = QLabel(self)
msg = self.tr('Please fill out all required (*) fields.')
msg = self._highlight_asterisk(msg)
self.required_fields_lbl.setText(msg)
self.gridLayout.addWidget(self.required_fields_lbl, next_row, 0, 1,
2)
# Bump up row reference
next_row += 1
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setObjectName('buttonBox')
self.gridLayout.addWidget(self.buttonBox, next_row, 0, 1, 1)
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Save)
if self.edit_model is None:
if not self.collect_model:
self.save_new_button = QPushButton(
QApplication.translate('EntityEditorDialog',
'Save and New'))
self.buttonBox.addButton(self.save_new_button,
QDialogButtonBox.ActionRole)
# edit model, collect model
# adding new record for child
# Saving in parent editor
if not isinstance(self._parent._parent, EntityEditorDialog):
# adding a new record
if self.edit_model is None:
# saving when digitizing.
if self.collect_model:
self.buttonBox.accepted.connect(self.on_model_added)
# saving parent editor
else:
self.buttonBox.accepted.connect(self.save_parent_editor)
self.save_new_button.clicked.connect(self.save_and_new)
# updating existing record
else:
if not self.collect_model:
# updating existing record of the parent editor
self.buttonBox.accepted.connect(self.save_parent_editor)
else:
self.buttonBox.accepted.connect(self.on_model_added)
# Saving in child editor
else:
# save and new record
if self.edit_model is None:
self.buttonBox.accepted.connect(self.on_child_saved)
self.save_new_button.clicked.connect(
lambda: self.on_child_saved(True))
else:
# When updating an existing child editor save to the db
self.buttonBox.accepted.connect(self.on_child_saved)
#self.buttonBox.accepted.connect(self.submit)
self.buttonBox.rejected.connect(self.cancel)
@property
def notification_bar(self):
"""
:return: Returns the dialog's notification bar.
:rtype: NotificationBar
"""
return self._notifBar
def save_parent_editor(self):
"""
Saves the parent editor and its children.
"""
self.submit()
self.save_children()
def set_parent_values(self):
"""
Sets the parent display column for the child.
"""
if self.parent_entity is None:
return
for col in self._entity.columns.values():
if col.TYPE_INFO == 'FOREIGN_KEY':
parent_entity = col.parent
if parent_entity == self.parent_entity:
self.parent_widgets_value_setter(self._parent._parent, col)
def parent_widgets_value_setter(self, parent, col):
"""
Finds and sets the value from parent widget and set it to the column
widget of a child using the child column.
:param parent: The parent widget
:type parent: QWidget
:param col: The child column object
:type col: Object
"""
for parent_col, parent_widget in parent.column_widgets.iteritems():
if parent_col.name == col.name:
self.single_parent_value_setter(col, parent_widget)
break
if parent_col.name in col.entity_relation.display_cols:
self.single_parent_value_setter(col, parent_widget)
break
def single_parent_value_setter(self, col, parent_widget):
"""
Gets value from parent widget and set it to the column widget of a
child using the child column.
:param parent: The parent widget
:type parent: QWidget
:param col: The child column object
:type col: Object
"""
local_widget = self.column_widgets[col]
local_widget.show_clear_button()
self.filter_val = parent_widget.text()
local_widget.setText(self.filter_val)
def save_and_new(self):
"""
A slot raised when Save and New button is click. It saves the form
without showing a success message. Then it sets reload_form property
to True so that entity_browser can re-load the form.
"""
from stdm.ui.entity_browser import (EntityBrowserWithEditor)
self.submit(False, True)
self.save_children()
if self.is_valid:
self.addedModel.emit(self.model())
self.setModel(self.ent_model())
self.clear()
self.child_models.clear()
for index in range(0, self.entity_tab_widget.count() - 1):
if isinstance(self.entity_tab_widget.widget(index),
EntityBrowserWithEditor):
child_browser = self.entity_tab_widget.widget(index)
child_browser.remove_rows()
def on_model_added(self):
"""
A slot raised when a form is submitted with collect model set to True.
There will be no success message and the form does not close.
"""
self.submit(True)
self.addedModel.emit(self.model())
def closeEvent(self, event):
'''
Raised when a request to close the window is received.
Check the dirty state of input controls and prompt user to
save if dirty.
'''
if self.do_not_check_dirty:
event.accept()
return
isDirty, userResponse = self.checkDirty()
if isDirty:
if userResponse == QMessageBox.Yes:
# We need to ignore the event so that validation and
# saving operations can be executed
event.ignore()
self.submit()
elif userResponse == QMessageBox.No:
event.accept()
elif userResponse == QMessageBox.Cancel:
event.ignore()
else:
event.accept()
def on_child_saved(self, save_and_new=False):
"""
A slot raised when the save or save and new button is clicked. It sets
the child_models dictionary of the parent when saved.
:param save_and_new: A boolean indicating the save and new button is
clicked to trigger the slot.
:type save_and_new: Boolean
"""
if self.parent_entity is None:
return
self.submit(True)
insert_pos = self._parent.tbEntity.model().rowCount() + 1
# Save to parent editor so that it is persistent.
self._parent._parent.child_models[insert_pos, self._entity] = \
self.model()
self.addedModel.emit(self.model())
if not save_and_new:
self.accept()
else:
if self.is_valid:
#self.addedModel.emit(self.model())
self.setModel(self.ent_model())
self.clear()
self.set_parent_values()
def save_children(self):
"""
Saves children models into the database by assigning the the id of the
parent for foreign key column.
"""
if len(self.child_models) < 1:
return
children_obj = []
for row_entity, model in self.child_models.iteritems():
row_pos = row_entity[0]
entity = row_entity[1]
ent_model = entity_model(entity)
entity_obj = ent_model()
for col in entity.columns.values():
if col.TYPE_INFO == 'FOREIGN_KEY':
if col.parent.name == self._entity.name:
setattr(model, col.name, self.model().id)
children_obj.append(model)
entity_obj.saveMany(children_obj)
def register_column_widgets(self):
"""
Registers the column widgets.
"""
# Append column labels and widgets
table_name = self._entity.name
columns = table_column_names(table_name)
self.scroll_widget_contents = QWidget()
self.scroll_widget_contents.setObjectName('scrollAreaWidgetContents')
for c in self._entity.columns.values():
if c.name in self.exclude_columns:
continue
if not c.name in columns and not isinstance(c, VirtualColumn):
continue
# Get widget factory
column_widget = ColumnWidgetRegistry.create(
c, self.scroll_widget_contents, host=self)
self.column_widgets[c] = column_widget
def _setup_columns_content_area(self):
# Only use this if entity supports documents
# self.entity_tab_widget = None
self.doc_widget = None
self.entity_scroll_area = QScrollArea(self)
self.entity_scroll_area.setFrameShape(QFrame.NoFrame)
self.entity_scroll_area.setWidgetResizable(True)
self.entity_scroll_area.setObjectName('scrollArea')
# Grid layout for controls
self.gl = QGridLayout(self.scroll_widget_contents)
self.gl.setObjectName('gl_widget_contents')
# Append column labels and widgets
table_name = self._entity.name
columns = table_column_names(table_name)
# Iterate entity column and assert if they exist
row_id = 0
for c, column_widget in self.column_widgets.iteritems():
if c.name in self.exclude_columns:
continue
if not c.name in columns and not isinstance(c, VirtualColumn):
continue
if column_widget is not None:
header = c.ui_display()
self.c_label = QLabel(self.scroll_widget_contents)
# Format label text if it is a mandatory field
if c.mandatory:
header = u'{0} *'.format(c.ui_display())
#Highlight asterisk
header = self._highlight_asterisk(header)
self.c_label.setText(header)
self.gl.addWidget(self.c_label, row_id, 0, 1, 1)
self.column_widget = column_widget
self.gl.addWidget(self.column_widget, row_id, 1, 1, 1)
#Add user tip if specified for the column configuration
if c.user_tip:
self.tip_lbl = UserTipLabel(user_tip=c.user_tip)
self.gl.addWidget(self.tip_lbl, row_id, 2, 1, 1)
if c.mandatory and not self.has_mandatory:
self.has_mandatory = True
col_name = c.name
#Replace name accordingly based on column type
if isinstance(c, MultipleSelectColumn):
col_name = c.model_attribute_name
# Add widget to MapperMixin collection
self.addMapping(col_name,
self.column_widget,
c.mandatory,
pseudoname=c.ui_display())
# Bump up row_id
row_id += 1
self.entity_scroll_area.setWidget(self.scroll_widget_contents)
if self.entity_tab_widget is None:
self.entity_tab_widget = QTabWidget(self)
# Check if there are children and add foreign key browsers
# Add primary tab if necessary
self._add_primary_attr_widget()
if not self._disable_collections:
ch_entities = self.children_entities()
for col, ch in ch_entities.iteritems():
if hasattr(col.entity_relation, 'show_in_parent'):
if col.entity_relation.show_in_parent != '0':
self._add_fk_browser(ch, col)
else:
self._add_fk_browser(ch, col)
#Add tab widget if entity supports documents
if self._entity.supports_documents:
self.doc_widget = SupportingDocumentsWidget(
self._entity.supporting_doc, self._ent_document_model, self)
# Map the source document manager object
self.addMapping('documents',
self.doc_widget.source_document_manager)
#
# # Add attribute tab
# self._add_primary_attr_widget()
# Add supporting documents tab
self.entity_tab_widget.addTab(self.doc_widget,
self.tr('Supporting Documents'))
# Return the correct widget
if not self.entity_tab_widget is None:
return self.entity_tab_widget
return self.entity_scroll_area
def _add_primary_attr_widget(self):
# Check if the primary entity
# exists and add if it does not
pr_txt = self.tr('Primary')
if not self.entity_tab_widget is None:
tab_txt = self.entity_tab_widget.tabText(0)
if not tab_txt == pr_txt:
self.entity_tab_widget.addTab(self.entity_scroll_area, pr_txt)
def _add_fk_browser(self, child_entity, column):
# Create and add foreign key
# browser to the collection
from stdm.ui.entity_browser import (EntityBrowserWithEditor)
attr = u'{0}_collection'.format(child_entity.name)
# Return if the attribute does not exist
if not hasattr(self._model, attr):
return
entity_browser = EntityBrowserWithEditor(child_entity,
self,
MANAGE,
False,
plugin=self.plugin)
entity_browser.buttonBox.setVisible(False)
entity_browser.record_filter = []
if len(child_entity.label) > 2:
column_label = child_entity.label
else:
# Split and join to filter out entity name prefix
# e.g. 'lo_parcel' to 'parcel'
column_label = format_name(" ".join(
child_entity.name.split("_", 1)[1:]))
self.entity_tab_widget.addTab(entity_browser,
u'{0}'.format(column_label))
self.set_filter(child_entity, entity_browser)
def set_filter(self, entity, browser):
col = self.filter_col(entity)
child_model = entity_model(entity)
child_model_obj = child_model()
col_obj = getattr(child_model, col.name)
if self.model() is not None:
if self.model().id is None:
browser.filtered_records = []
else:
browser.filtered_records = child_model_obj.queryObject(
).filter(col_obj == self.model().id).all()
if self.edit_model is not None:
browser.filtered_records = child_model_obj.queryObject().filter(
col_obj == self.edit_model.id).all()
if self.edit_model is None and self.model() is None:
browser.filtered_records = []
def filter_col(self, child_entity):
for col in child_entity.columns.values():
if col.TYPE_INFO == 'FOREIGN_KEY':
parent_entity = col.parent
if parent_entity == self._entity:
return col
def children_entities(self):
"""
:return: Returns a list of children entities
that refer to the main entity as the parent.
:rtype: OrderedDict
"""
child_columns = OrderedDict()
for ch in self._entity.children():
if ch.TYPE_INFO == Entity.TYPE_INFO:
for col in ch.columns.values():
if hasattr(col, 'entity_relation'):
if col.parent.name == self._entity.name:
child_columns[col] = ch
return child_columns
def document_widget(self):
"""
:return: Returns the widget for managing
the supporting documents for an entity if enabled.
:rtype: SupportingDocumentsWidget
"""
return self.doc_widget
def source_document_manager(self):
"""
:return: Returns an instance of the
SourceDocumentManager only if supporting
documents are enabled for the given entity. Otherwise,
None if supporting documents are not enabled.
:rtype: SourceDocumentManager
"""
if self.doc_widget is None:
return None
return self.doc_widget.source_document_manager
def _highlight_asterisk(self, text):
# Highlight asterisk in red
c = '*'
# Do not format if there is no asterisk
if text.find(c) == -1:
return text
asterisk_highlight = '<span style=\" color:#ff0000;\">*</span>'
text = text.replace(c, asterisk_highlight)
return u'<html><head/><body><p>{0}</p></body></html>'.format(text)
def _custom_validate(self):
"""
Override of the MapperMixin which enables custom editor extensions to
inject additional validation before saving form data.
:return: Return True if the validation was successful,
otherwise False.
:rtype: bool
"""
if not self._editor_ext is None:
return self._editor_ext.validate()
# Return True if there is no custom editor extension specified
return True
def _post_save(self, model):
"""
Include additional post-save logic by custom extensions.
:param model: SQLAlchemy model
:type model: object
"""
if not self._editor_ext is None:
self._editor_ext.post_save(model)
def _get_entity_editor_widgets(self):
"""
Gets entity editor widgets and appends them to a dictionary
"""
if self.entity_tab_widget:
tab_count = self.entity_tab_widget.count()
for i in range(tab_count):
tab_object = self.entity_tab_widget.widget(i)
tab_text = self.entity_tab_widget.tabText(i)
self.entity_editor_widgets[tab_text] = tab_object
else:
self.entity_editor_widgets['no_tab'] = self.entity_scroll_area
def __init__(self, nbprocessors):
QDialog.__init__(self)
self.layout = QVBoxLayout(self)
self.taskset = None
# Utilizations:
vbox_utilizations = QVBoxLayout()
group = QGroupBox("Task Utilizations:")
hbox = QHBoxLayout()
hbox.addWidget(QLabel("Generator:", self))
self.comboGenerator = QComboBox()
self.comboGenerator.addItem("RandFixedSum")
self.comboGenerator.addItem("UUniFast-Discard")
self.comboGenerator.addItem("Kato's method")
self.comboGenerator.currentIndexChanged.connect(self.generator_changed)
hbox.addWidget(self.comboGenerator)
vbox_utilizations.addLayout(hbox)
# Load slider + spinner:
hbox_load = QHBoxLayout()
sld = _DoubleSlider(QtCore.Qt.Horizontal, self)
sld.setMinimum(0)
sld.setMaximum(32)
self.spin_load = QDoubleSpinBox(self)
self.spin_load.setMinimum(0)
self.spin_load.setMaximum(32)
self.spin_load.setSingleStep(0.1)
hbox_load.addWidget(QLabel("Total utilization: ", self))
hbox_load.addWidget(sld)
hbox_load.addWidget(self.spin_load)
sld.doubleValueChanged.connect(self.spin_load.setValue)
self.spin_load.valueChanged.connect(sld.setValue)
self.spin_load.setValue(nbprocessors / 2.)
vbox_utilizations.addLayout(hbox_load)
# Number of periodic tasks:
self.hbox_tasks = QHBoxLayout()
self.spin_tasks = QSpinBox(self)
self.spin_tasks.setMinimum(0)
self.spin_tasks.setMaximum(999) # That's arbitrary.
self.hbox_tasks.addWidget(QLabel("Number of periodic tasks: ", self))
self.hbox_tasks.addStretch(1)
self.hbox_tasks.addWidget(self.spin_tasks)
vbox_utilizations.addLayout(self.hbox_tasks)
# Number of sporadic tasks:
self.hbox_sporadic_tasks = QHBoxLayout()
self.spin_sporadic_tasks = QSpinBox(self)
self.spin_sporadic_tasks.setMinimum(0)
self.spin_sporadic_tasks.setMaximum(999) # That's arbitrary.
self.hbox_sporadic_tasks.addWidget(
QLabel("Number of sporadic tasks: ", self))
self.hbox_sporadic_tasks.addStretch(1)
self.hbox_sporadic_tasks.addWidget(self.spin_sporadic_tasks)
vbox_utilizations.addLayout(self.hbox_sporadic_tasks)
# Min / Max utilizations
self.hbox_utilizations = QHBoxLayout()
self.hbox_utilizations.addWidget(QLabel("Min/Max utilizations: ",
self))
self.interval_utilization = IntervalSpinner(self,
min_=0,
max_=1,
step=.01,
round_option=False)
self.hbox_utilizations.addWidget(self.interval_utilization)
vbox_utilizations.addLayout(self.hbox_utilizations)
group.setLayout(vbox_utilizations)
self.layout.addWidget(group)
# Periods:
vbox_periods = QVBoxLayout()
group = QGroupBox("Task Periods:")
# Log uniform
self.lunif = QRadioButton("log-uniform distribution between:")
vbox_periods.addWidget(self.lunif)
self.lunif.setChecked(True)
self.lunif_interval = IntervalSpinner(self)
self.lunif_interval.setEnabled(self.lunif.isChecked())
self.lunif.toggled.connect(self.lunif_interval.setEnabled)
vbox_periods.addWidget(self.lunif_interval)
# Uniform
self.unif = QRadioButton("uniform distribution between:")
vbox_periods.addWidget(self.unif)
self.unif_interval = IntervalSpinner(self)
self.unif_interval.setEnabled(self.unif.isChecked())
self.unif.toggled.connect(self.unif_interval.setEnabled)
vbox_periods.addWidget(self.unif_interval)
# Discrete
discrete = QRadioButton("chosen among these (space separated) values:")
vbox_periods.addWidget(discrete)
self.periods = QLineEdit(self)
self.periods.setValidator(
QRegExpValidator(QRegExp("^\\d*(\.\\d*)?( \\d*(\.\\d*)?)*$")))
vbox_periods.addWidget(self.periods)
self.periods.setEnabled(discrete.isChecked())
discrete.toggled.connect(self.periods.setEnabled)
vbox_periods.addStretch(1)
group.setLayout(vbox_periods)
self.layout.addWidget(group)
buttonBox = QDialogButtonBox()
cancel = buttonBox.addButton(QDialogButtonBox.Cancel)
generate = buttonBox.addButton("Generate", QDialogButtonBox.AcceptRole)
cancel.clicked.connect(self.reject)
generate.clicked.connect(self.generate)
self.layout.addWidget(buttonBox)
self.show_randfixedsum_options()
def __init__(self,
parent=None,
signalManager=None,
title="CSV File Import"):
OWWidget.__init__(self,
parent,
signalManager,
title,
wantMainArea=False,
noReport=True)
self.symbol_DC = ""
self.symbol_DK = ""
#: List of recent opened files.
self.recent_files = []
#: Current selected file name
self.selected_file = None
#: Variable reuse flag
self.create_new_on = 2
#: Display advanced var reuse options
self.show_advanced = False
self.loadSettings()
self.recent_files = filter(os.path.exists, self.recent_files)
self._loader = None
self._invalidated = False
self._datareport = None
layout = QHBoxLayout()
OWGUI.widgetBox(self.controlArea, "File", orientation=layout)
icons = standard_icons(self)
self.recent_combo = QComboBox(self,
objectName="recent_combo",
toolTip="Recent files.",
activated=self.activate_recent)
cb_append_file_list(self.recent_combo, self.recent_files)
self.recent_combo.insertSeparator(self.recent_combo.count())
self.recent_combo.addItem(u"Browse documentation data sets…")
self.browse_button = QPushButton(u"…",
icon=icons.dir_open_icon,
toolTip="Browse filesystem",
clicked=self.browse)
self.reload_button = QPushButton("Reload",
icon=icons.reload_icon,
toolTip="Reload the selected file",
clicked=self.reload,
default=True)
layout.addWidget(self.recent_combo, 2)
layout.addWidget(self.browse_button)
layout.addWidget(self.reload_button)
###########
# Info text
###########
box = OWGUI.widgetBox(self.controlArea, "Info", addSpace=True)
self.infoa = OWGUI.widgetLabel(box, "No data loaded.")
self.infob = OWGUI.widgetLabel(box, " ")
self.warnings = OWGUI.widgetLabel(box, " ")
# Set word wrap so long warnings won't expand the widget
self.warnings.setWordWrap(True)
self.warnings.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.MinimumExpanding)
advanced = QGroupBox("Advanced Settings",
checkable=True,
checked=self.show_advanced)
advanced.setLayout(QVBoxLayout())
def set_group_visible(groupbox, state):
layout = groupbox.layout()
for i in range(layout.count()):
item = layout.itemAt(i)
widget = item.widget()
if widget is not None:
widget.setVisible(state)
groupbox.setFlat(not state)
def toogle_advanced(state):
self.show_advanced = state
set_group_visible(advanced, state)
self.layout().activate()
QApplication.instance().processEvents()
QTimer.singleShot(0, self.adjustSize)
advanced.toggled.connect(toogle_advanced)
self.taboptions = QWidget()
self.taboptions.setLayout(QVBoxLayout())
box = QGroupBox("Missing Value Symbols", flat=True)
form = QFormLayout(fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
form.addRow(
"Don't care:",
OWGUI.lineEdit(None,
self,
"symbol_DC",
tooltip="Default values: '~' or '*'"))
form.addRow(
"Don't know:",
OWGUI.lineEdit(None,
self,
"symbol_DK",
tooltip="Default values: empty fields (space), "
"'?' or 'NA'"))
box.setLayout(form)
advanced.layout().addWidget(box)
rb = OWGUI.radioButtonsInBox(
advanced,
self,
"create_new_on",
box="New Attributes",
callback=self._invalidate,
label=u"Create a new attribute when existing attribute(s) …",
btnLabels=[
u"Have mismatching order of values",
u"Have no common values with the new (recommended)",
u"Miss some values of the new attribute",
u"… Always create a new attribute"
])
rb.setFlat(True)
self.controlArea.layout().addWidget(advanced)
button_box = QDialogButtonBox(orientation=Qt.Horizontal)
self.import_options_button = QPushButton(u"Import Options…",
enabled=False)
self.import_options_button.pressed.connect(
self._activate_import_dialog)
button_box.addButton(self.import_options_button,
QDialogButtonBox.ActionRole)
button_box.addButton(
QPushButton("&Report", pressed=self.reportAndFinish),
QDialogButtonBox.ActionRole)
self.controlArea.layout().addWidget(button_box)
OWGUI.rubber(self.controlArea)
set_group_visible(advanced, self.show_advanced)
if self.recent_files and self.recent_files[0] == self.selected_file:
QTimer.singleShot(0, lambda: self.activate_recent(0))
else:
self.selected_file = None
self.recent_combo.setCurrentIndex(-1)
def initUI(self):
u"""Build the dialog box."""
language_help = _(u'''<h4>Language code.</h4>
<p>This will be transmitted as part of the requst sent to the
sites. As some sites only support one language, this is also used to
decide where to send the requests. Use a standard language code
here. Using invalid values or codes of unsupported languages will
result in no downloads. Do <em>not</em> use domain codes (E.g. use
<code>zh</code> rather than <code>cn</code> for Chinese.)</p>''')
self.setWindowTitle(_(u'Anki – Download audio'))
self.setWindowIcon(QIcon(":/icons/anki.png"))
layout = QVBoxLayout()
self.setLayout(layout)
edit_word_head = QLabel()
kanji_et = _('''\
<h4>Requests to send to the download sites</h4>
<p>In the split edit fields, set the kanji on the left, the
kana on the right.</p>
''')
base_et = _('''\
<h4>Requests to send to the download sites</h4>
<p>In split edit fields, set the expression (base) on the left, the
reading (ruby) on the right.</p>
''')
single_et = _('''\
<h4>Requests to send to the download sites</h4>
''')
# Now decide which help text to show.
# First, decide if we have any split fields.
if any(f_data.split for f_data in self.field_data_list):
if self.language_code and self.language_code.startswith('ja'):
# Japanese
edit_word_head.setText(kanji_et)
else:
# Chinese should not happen at the moment
edit_word_head.setText(base_et)
else:
edit_word_head.setText(single_et)
layout.addWidget(edit_word_head)
self.create_data_rows(layout)
line = QFrame(self)
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
layout.addWidget(line)
lcode_head = QLabel(_('''<h4>Language code</h4>'''))
layout.addWidget(lcode_head)
lang_hlayout = QHBoxLayout()
lc_label = QLabel(_(u'Language code:'), self)
lang_hlayout.addWidget(lc_label)
lc_label.setToolTip(language_help)
self.language_code_lineedit = QLineEdit(self)
try:
self.language_code_lineedit.setText(self.language_code)
except:
self.language_code_lineedit.setText(default_audio_language_code)
lang_hlayout.addWidget(self.language_code_lineedit)
self.language_code_lineedit.setToolTip(language_help)
layout.addLayout(lang_hlayout)
dialog_buttons = QDialogButtonBox(self)
dialog_buttons.addButton(QDialogButtonBox.Cancel)
dialog_buttons.addButton(QDialogButtonBox.Ok)
self.connect(dialog_buttons, SIGNAL("accepted()"), self,
SLOT("accept()"))
self.connect(dialog_buttons, SIGNAL("rejected()"), self,
SLOT("reject()"))
layout.addWidget(dialog_buttons)
def __createLayout(self):
""" Creates the dialog layout """
self.resize(600, 300)
self.setSizeGripEnabled(True)
verticalLayout = QVBoxLayout(self)
gridLayout = QGridLayout()
# Combo box for the text to search
findLabel = QLabel(self)
findLabel.setText("Find text:")
self.findCombo = QComboBox(self)
self.__tuneCombo(self.findCombo)
self.findCombo.lineEdit().setToolTip(
"Regular expression to search for")
self.findCombo.editTextChanged.connect(self.__someTextChanged)
gridLayout.addWidget(findLabel, 0, 0, 1, 1)
gridLayout.addWidget(self.findCombo, 0, 1, 1, 1)
verticalLayout.addLayout(gridLayout)
# Check boxes
horizontalCBLayout = QHBoxLayout()
self.caseCheckBox = QCheckBox(self)
self.caseCheckBox.setText("Match &case")
horizontalCBLayout.addWidget(self.caseCheckBox)
self.wordCheckBox = QCheckBox(self)
self.wordCheckBox.setText("Match whole &word")
horizontalCBLayout.addWidget(self.wordCheckBox)
self.regexpCheckBox = QCheckBox(self)
self.regexpCheckBox.setText("Regular &expression")
horizontalCBLayout.addWidget(self.regexpCheckBox)
verticalLayout.addLayout(horizontalCBLayout)
# Files groupbox
filesGroupbox = QGroupBox(self)
filesGroupbox.setTitle("Find in")
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
filesGroupbox.sizePolicy().hasHeightForWidth())
filesGroupbox.setSizePolicy(sizePolicy)
gridLayoutFG = QGridLayout(filesGroupbox)
self.projectRButton = QRadioButton(filesGroupbox)
self.projectRButton.setText("&Project")
gridLayoutFG.addWidget(self.projectRButton, 0, 0)
self.projectRButton.clicked.connect(self.__projectClicked)
self.openFilesRButton = QRadioButton(filesGroupbox)
self.openFilesRButton.setText("&Opened files only")
gridLayoutFG.addWidget(self.openFilesRButton, 1, 0)
self.openFilesRButton.clicked.connect(self.__openFilesOnlyClicked)
self.dirRButton = QRadioButton(filesGroupbox)
self.dirRButton.setText("&Directory tree")
gridLayoutFG.addWidget(self.dirRButton, 2, 0)
self.dirRButton.clicked.connect(self.__dirClicked)
self.dirEditCombo = QComboBox(filesGroupbox)
self.__tuneCombo(self.dirEditCombo)
self.dirEditCombo.lineEdit().setToolTip("Directory to search in")
gridLayoutFG.addWidget(self.dirEditCombo, 2, 1)
self.dirEditCombo.editTextChanged.connect(self.__someTextChanged)
self.dirSelectButton = QPushButton(filesGroupbox)
self.dirSelectButton.setText("...")
gridLayoutFG.addWidget(self.dirSelectButton, 2, 2)
self.dirSelectButton.clicked.connect(self.__selectDirClicked)
filterLabel = QLabel(filesGroupbox)
filterLabel.setText("Files filter:")
gridLayoutFG.addWidget(filterLabel, 3, 0)
self.filterCombo = QComboBox(filesGroupbox)
self.__tuneCombo(self.filterCombo)
self.filterCombo.lineEdit().setToolTip("File names regular expression")
gridLayoutFG.addWidget(self.filterCombo, 3, 1)
self.filterCombo.editTextChanged.connect(self.__someTextChanged)
verticalLayout.addWidget(filesGroupbox)
# File label
self.fileLabel = FitPathLabel(self)
self.fileLabel.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Fixed)
verticalLayout.addWidget(self.fileLabel)
# Progress bar
self.progressBar = QProgressBar(self)
self.progressBar.setValue(0)
self.progressBar.setOrientation(Qt.Horizontal)
verticalLayout.addWidget(self.progressBar)
# Buttons at the bottom
buttonBox = QDialogButtonBox(self)
buttonBox.setOrientation(Qt.Horizontal)
buttonBox.setStandardButtons(QDialogButtonBox.Cancel)
self.findButton = buttonBox.addButton("Find",
QDialogButtonBox.AcceptRole)
self.findButton.setDefault(True)
self.findButton.clicked.connect(self.__process)
verticalLayout.addWidget(buttonBox)
buttonBox.rejected.connect(self.__onClose)
return
class WellMarkerDialog(QDialog):
def __init__(self, well):
super(WellMarkerDialog, self).__init__()
self.well = well
self.setupUi()
self.initUI()
self.button_box.accepted.connect(self.save_markers)
self.button_box.rejected.connect(self.close)
self.add_Button.clicked.connect(self.add_row)
self.del_Button.clicked.connect(self.del_row)
self.export_Button.clicked.connect(self.export_markers)
self.import_Button.clicked.connect(self.import_markers)
def setupUi(self):
self.resize(568, 411)
self.setWindowIcon(QIcon(':/icon/layer_icon'))
self.setWindowTitle("Edit Markers")
self.gridLayout = QGridLayout(self)
# table widget
self.tableWidget = QTableWidget(self)
self.tableWidget.setColumnCount(4)
self.tableWidget.setRowCount(0)
self.tableWidget.setHorizontalHeaderItem(0, QTableWidgetItem("Name"))
self.tableWidget.setHorizontalHeaderItem(1,
QTableWidgetItem("TVD (m)"))
self.tableWidget.setHorizontalHeaderItem(2,
QTableWidgetItem("TVDSS (m)"))
self.tableWidget.setHorizontalHeaderItem(3, QTableWidgetItem("Color"))
self.gridLayout.addWidget(self.tableWidget, 0, 0, 1, 1)
# button box
self.button_box = QDialogButtonBox(self)
self.export_Button = self.button_box.addButton(
"Export", QDialogButtonBox.ResetRole)
self.import_Button = self.button_box.addButton(
"Import", QDialogButtonBox.ResetRole)
self.add_Button = self.button_box.addButton("Add",
QDialogButtonBox.ResetRole)
self.del_Button = self.button_box.addButton("Del",
QDialogButtonBox.ResetRole)
self.button_box.setStandardButtons(QDialogButtonBox.Save
| QDialogButtonBox.Cancel)
self.gridLayout.addWidget(self.button_box, 1, 0, 1, 1)
def initUI(self):
self.populate_marker_table()
def populate_marker_table(self):
try:
markers_dict = self.well.params["horizon"]
for mark in markers_dict.keys():
self.tableWidget.insertRow(0)
self.tableWidget.setItem(0, 0, QTableWidgetItem(mark))
self.tableWidget.setItem(
0, 1, QTableWidgetItem(str(markers_dict[mark])))
self.tableWidget.setItem(
0, 2, QTableWidgetItem(str(markers_dict[mark])))
self.tableWidget.sortItems(0, Qt.AscendingOrder)
except KeyError:
pass
def add_row(self):
self.tableWidget.insertRow(self.tableWidget.rowCount())
def del_row(self):
self.tableWidget.removeRow(self.tableWidget.currentRow())
def save_markers(self):
l_names = [str(self.tableWidget.item(irow, 0).text()) \
for irow in range(self.tableWidget.rowCount())]
l_md = [float(self.tableWidget.item(irow, 1).text()) \
for irow in range(self.tableWidget.rowCount())]
new_dict = OrderedDict([(a, b) for a, b in zip(l_names, l_md)])
if self.well.params['horizon'] != new_dict:
respond = QMessageBox.question(
self, "Save Markers", "Sure to save changes?",
QMessageBox.Save | QMessageBox.Cancel)
if respond == QMessageBox.Save:
self.well.params['horizon'] = new_dict
self.well.save_params()
self.close()
def export_markers(self):
file_path = str(QFileDialog.getSaveFileName(self, "Save Markers"))
l_names = [str(self.tableWidget.item(irow, 0).text()) \
for irow in range(self.tableWidget.rowCount())]
l_md = [float(self.tableWidget.item(irow, 1).text()) \
for irow in range(self.tableWidget.rowCount())]
df = pd.DataFrame({"name": l_names, "MD(m)": l_md})
df.to_csv(file_path, sep='\t', columns=["name", "MD(m)"], index=False)
QMessageBox.information(self, "Export Markers", "Succeed!")
def import_markers(self):
read_csv_dialog = ReadCsvDialog()
read_csv_dialog.setWindowIcon(QIcon(':/icon/layer_icon'))
read_csv_dialog.setWindowTitle("Open Markers File")
read_csv_dialog.label.setText("Read Makers from File")
read_csv_dialog.exec_()
def __createLayout(self, action):
""" Creates the dialog layout """
self.resize(650, 300)
self.setSizeGripEnabled(True)
# Top level layout
layout = QVBoxLayout(self)
# Cmd line arguments
argsLabel = QLabel("Command line arguments")
self.__argsEdit = QLineEdit()
self.__argsEdit.textChanged.connect(self.__argsChanged)
argsLayout = QHBoxLayout()
argsLayout.addWidget(argsLabel)
argsLayout.addWidget(self.__argsEdit)
layout.addLayout(argsLayout)
# Working directory
workDirGroupbox = QGroupBox(self)
workDirGroupbox.setTitle("Working directory")
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth( \
workDirGroupbox.sizePolicy().hasHeightForWidth() )
workDirGroupbox.setSizePolicy(sizePolicy)
gridLayoutWD = QGridLayout(workDirGroupbox)
self.__scriptWDRButton = QRadioButton(workDirGroupbox)
self.__scriptWDRButton.setText("&Use script location")
gridLayoutWD.addWidget(self.__scriptWDRButton, 0, 0)
self.__scriptWDRButton.clicked.connect(self.__scriptWDirClicked)
self.__dirRButton = QRadioButton(workDirGroupbox)
self.__dirRButton.setText("Select &directory")
gridLayoutWD.addWidget(self.__dirRButton, 1, 0)
self.__dirRButton.clicked.connect(self.__dirClicked)
self.__dirEdit = QLineEdit(workDirGroupbox)
gridLayoutWD.addWidget(self.__dirEdit, 1, 1)
self.__dirEdit.textChanged.connect(self.__workingDirChanged)
self.__dirSelectButton = QPushButton(workDirGroupbox)
self.__dirSelectButton.setText("...")
gridLayoutWD.addWidget(self.__dirSelectButton, 1, 2)
self.__dirSelectButton.clicked.connect(self.__selectDirClicked)
layout.addWidget(workDirGroupbox)
# Environment
envGroupbox = QGroupBox(self)
envGroupbox.setTitle("Environment")
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth( \
envGroupbox.sizePolicy().hasHeightForWidth() )
envGroupbox.setSizePolicy(sizePolicy)
layoutEnv = QVBoxLayout(envGroupbox)
self.__inheritParentRButton = QRadioButton(envGroupbox)
self.__inheritParentRButton.setText("Inherit &parent")
self.__inheritParentRButton.clicked.connect(self.__inhClicked)
layoutEnv.addWidget(self.__inheritParentRButton)
self.__inheritParentPlusRButton = QRadioButton(envGroupbox)
self.__inheritParentPlusRButton.setText(
"Inherit parent and add/&modify")
self.__inheritParentPlusRButton.clicked.connect(self.__inhPlusClicked)
layoutEnv.addWidget(self.__inheritParentPlusRButton)
hInhPlusLayout = QHBoxLayout()
self.__inhPlusEnvTable = QTreeWidget()
self.__inhPlusEnvTable.itemActivated.connect(
self.__inhPlusItemActivated)
self.__tuneTable(self.__inhPlusEnvTable)
hInhPlusLayout.addWidget(self.__inhPlusEnvTable)
vInhPlusLayout = QVBoxLayout()
self.__addInhButton = QPushButton()
self.__addInhButton.clicked.connect(self.__addInhClicked)
self.__addInhButton.setText('Add')
vInhPlusLayout.addWidget(self.__addInhButton)
self.__delInhButton = QPushButton()
self.__delInhButton.clicked.connect(self.__delInhClicked)
self.__delInhButton.setText('Delete')
vInhPlusLayout.addWidget(self.__delInhButton)
self.__editInhButton = QPushButton()
self.__editInhButton.clicked.connect(self.__editInhClicked)
self.__editInhButton.setText("Edit")
vInhPlusLayout.addWidget(self.__editInhButton)
hInhPlusLayout.addLayout(vInhPlusLayout)
layoutEnv.addLayout(hInhPlusLayout)
self.__specificRButton = QRadioButton(envGroupbox)
self.__specificRButton.setText("&Specific")
self.__specificRButton.clicked.connect(self.__specClicked)
layoutEnv.addWidget(self.__specificRButton)
hSpecLayout = QHBoxLayout()
self.__specEnvTable = QTreeWidget()
self.__specEnvTable.itemActivated.connect(self.__specItemActivated)
self.__tuneTable(self.__specEnvTable)
hSpecLayout.addWidget(self.__specEnvTable)
vSpecLayout = QVBoxLayout()
self.__addSpecButton = QPushButton()
self.__addSpecButton.clicked.connect(self.__addSpecClicked)
self.__addSpecButton.setText('Add')
vSpecLayout.addWidget(self.__addSpecButton)
self.__delSpecButton = QPushButton()
self.__delSpecButton.clicked.connect(self.__delSpecClicked)
self.__delSpecButton.setText('Delete')
vSpecLayout.addWidget(self.__delSpecButton)
self.__editSpecButton = QPushButton()
self.__editSpecButton.clicked.connect(self.__editSpecClicked)
self.__editSpecButton.setText("Edit")
vSpecLayout.addWidget(self.__editSpecButton)
hSpecLayout.addLayout(vSpecLayout)
layoutEnv.addLayout(hSpecLayout)
layout.addWidget(envGroupbox)
# Terminal and profile limits
if self.__action in ["profile", "debug"]:
layout.addWidget(self.__getIDEWideGroupbox())
else:
termGroupbox = self.__getTermGroupbox()
termGroupbox.setTitle("Terminal to run in (IDE wide setting)")
layout.addWidget(termGroupbox)
# Close checkbox
self.__closeCheckBox = QCheckBox("&Close terminal upon "
"successful completion")
self.__closeCheckBox.stateChanged.connect(self.__onCloseChanged)
layout.addWidget(self.__closeCheckBox)
# Buttons at the bottom
buttonBox = QDialogButtonBox(self)
buttonBox.setOrientation(Qt.Horizontal)
buttonBox.setStandardButtons(QDialogButtonBox.Cancel)
self.__runButton = buttonBox.addButton(action,
QDialogButtonBox.AcceptRole)
self.__runButton.setDefault(True)
self.__runButton.clicked.connect(self.onAccept)
layout.addWidget(buttonBox)
buttonBox.rejected.connect(self.close)
return
def __init__(self, parent=None, signalManager=None,
title="CSV File Import"):
OWWidget.__init__(self, parent, signalManager, title,
wantMainArea=False, noReport=True)
self.symbol_DC = ""
self.symbol_DK = ""
#: List of recent opened files.
self.recent_files = []
#: Current selected file name
self.selected_file = None
#: Variable reuse flag
self.create_new_on = 2
#: Display advanced var reuse options
self.show_advanced = False
self.loadSettings()
self.recent_files = filter(os.path.exists, self.recent_files)
self._loader = None
self._invalidated = False
self._datareport = None
layout = QHBoxLayout()
OWGUI.widgetBox(self.controlArea, "File", orientation=layout)
icons = standard_icons(self)
self.recent_combo = QComboBox(
self, objectName="recent_combo",
toolTip="Recent files.",
activated=self.activate_recent
)
cb_append_file_list(self.recent_combo, self.recent_files)
self.recent_combo.insertSeparator(self.recent_combo.count())
self.recent_combo.addItem(u"Browse documentation data sets…")
self.browse_button = QPushButton(
u"…",
icon=icons.dir_open_icon, toolTip="Browse filesystem",
clicked=self.browse
)
self.reload_button = QPushButton(
"Reload", icon=icons.reload_icon,
toolTip="Reload the selected file", clicked=self.reload,
default=True
)
layout.addWidget(self.recent_combo, 2)
layout.addWidget(self.browse_button)
layout.addWidget(self.reload_button)
###########
# Info text
###########
box = OWGUI.widgetBox(self.controlArea, "Info", addSpace=True)
self.infoa = OWGUI.widgetLabel(box, "No data loaded.")
self.infob = OWGUI.widgetLabel(box, " ")
self.warnings = OWGUI.widgetLabel(box, " ")
# Set word wrap so long warnings won't expand the widget
self.warnings.setWordWrap(True)
self.warnings.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.MinimumExpanding)
advanced = QGroupBox(
"Advanced Settings", checkable=True, checked=self.show_advanced
)
advanced.setLayout(QVBoxLayout())
def set_group_visible(groupbox, state):
layout = groupbox.layout()
for i in range(layout.count()):
item = layout.itemAt(i)
widget = item.widget()
if widget is not None:
widget.setVisible(state)
groupbox.setFlat(not state)
def toogle_advanced(state):
self.show_advanced = state
set_group_visible(advanced, state)
self.layout().activate()
QApplication.instance().processEvents()
QTimer.singleShot(0, self.adjustSize)
advanced.toggled.connect(toogle_advanced)
self.taboptions = QWidget()
self.taboptions.setLayout(QVBoxLayout())
box = QGroupBox("Missing Value Symbols", flat=True)
form = QFormLayout(fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
form.addRow(
"Don't care:",
OWGUI.lineEdit(None, self, "symbol_DC",
tooltip="Default values: '~' or '*'"))
form.addRow(
"Don't know:",
OWGUI.lineEdit(None, self, "symbol_DK",
tooltip="Default values: empty fields (space), "
"'?' or 'NA'"))
box.setLayout(form)
advanced.layout().addWidget(box)
rb = OWGUI.radioButtonsInBox(
advanced, self, "create_new_on",
box="New Attributes",
callback=self._invalidate,
label=u"Create a new attribute when existing attribute(s) …",
btnLabels=[u"Have mismatching order of values",
u"Have no common values with the new (recommended)",
u"Miss some values of the new attribute",
u"… Always create a new attribute"]
)
rb.setFlat(True)
self.controlArea.layout().addWidget(advanced)
button_box = QDialogButtonBox(orientation=Qt.Horizontal)
self.import_options_button = QPushButton(
u"Import Options…", enabled=False
)
self.import_options_button.pressed.connect(self._activate_import_dialog)
button_box.addButton(
self.import_options_button, QDialogButtonBox.ActionRole
)
button_box.addButton(
QPushButton("&Report", pressed=self.reportAndFinish),
QDialogButtonBox.ActionRole
)
self.controlArea.layout().addWidget(button_box)
OWGUI.rubber(self.controlArea)
set_group_visible(advanced, self.show_advanced)
if self.recent_files and self.recent_files[0] == self.selected_file:
QTimer.singleShot(
0, lambda: self.activate_recent(0)
)
else:
self.selected_file = None
self.recent_combo.setCurrentIndex(-1)
class Games(QDialog):
"""a dialog for selecting a game"""
def __init__(self, parent=None):
super(Games, self).__init__(parent)
self.selectedGame = None
self.onlyPending = True
self.setWindowTitle(m18nc('kajongg', 'Games') + ' - Kajongg')
self.setObjectName('Games')
self.resize(700, 400)
self.model = GamesModel(self)
if Debug.modelTest:
self.modelTest = ModelTest(self.model, self)
self.view = MJTableView(self)
self.view.setModel(self.model)
self.selection = QItemSelectionModel(self.model, self.view)
self.view.setSelectionModel(self.selection)
self.view.setSelectionBehavior(QAbstractItemView.SelectRows)
self.view.setSelectionMode(QAbstractItemView.SingleSelection)
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel)
self.newButton = self.buttonBox.addButton(
m18nc('start a new game', "&New"), QDialogButtonBox.ActionRole)
self.newButton.setIcon(KIcon("document-new"))
self.newButton.clicked.connect(self.accept)
self.loadButton = self.buttonBox.addButton(m18n("&Load"),
QDialogButtonBox.AcceptRole)
self.loadButton.clicked.connect(self.loadGame)
self.loadButton.setIcon(KIcon("document-open"))
self.deleteButton = self.buttonBox.addButton(
m18n("&Delete"), QDialogButtonBox.ActionRole)
self.deleteButton.setIcon(KIcon("edit-delete"))
self.deleteButton.clicked.connect(self.delete)
chkPending = QCheckBox(m18n("Show only pending games"), self)
chkPending.setChecked(True)
cmdLayout = QHBoxLayout()
cmdLayout.addWidget(chkPending)
cmdLayout.addWidget(self.buttonBox)
layout = QVBoxLayout()
layout.addWidget(self.view)
layout.addLayout(cmdLayout)
self.setLayout(layout)
StateSaver(self)
self.selection.selectionChanged.connect(self.selectionChanged)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
self.view.doubleClicked.connect(self.loadGame)
chkPending.stateChanged.connect(self.pendingOrNot)
def showEvent(self, dummyEvent):
"""only now get the data set. Not doing this in__init__ would eventually
make it easier to subclass from some generic TableEditor class"""
self.setQuery()
self.view.initView()
self.selectionChanged()
def keyPressEvent(self, event):
"""use insert/delete keys for insert/delete"""
key = event.key()
if key == Qt.Key_Insert:
self.newEntry()
return
if key == Qt.Key_Delete:
self.delete()
event.ignore()
return
QDialog.keyPressEvent(self, event)
def selectionChanged(self):
"""update button states according to selection"""
selectedRows = len(self.selection.selectedRows())
self.loadButton.setEnabled(selectedRows == 1)
self.deleteButton.setEnabled(selectedRows >= 1)
def setQuery(self):
"""define the query depending on self.OnlyPending"""
query = "select g.id, g.starttime, " \
"p0.name||'///'||p1.name||'///'||p2.name||'///'||p3.name " \
"from game g, player p0," \
"player p1, player p2, player p3 " \
"where seed is null" \
" and p0.id=g.p0 and p1.id=g.p1 " \
" and p2.id=g.p2 and p3.id=g.p3 " \
"%s" \
"and exists(select 1 from score where game=g.id)" % \
("and g.endtime is null " if self.onlyPending else "")
self.model.setQuery(query, DBHandle.default)
self.model.setHeaderData(1, Qt.Horizontal, QVariant(m18n("Started")))
self.model.setHeaderData(2, Qt.Horizontal, QVariant(m18n("Players")))
self.view.hideColumn(0)
def __idxForGame(self, game):
"""returns the model index for game"""
for row in range(self.model.rowCount()):
if self.model.record(row).field(0).value().toInt()[0] == game:
return self.model.index(row, 0)
return self.model.index(0, 0)
def pendingOrNot(self, chosen):
"""do we want to see all games or only pending games?"""
if self.onlyPending != chosen:
self.onlyPending = chosen
idx = self.view.currentIndex()
selectedGame = self.model.record(idx.row()).value(0).toInt()[0]
self.setQuery()
idx = self.__idxForGame(selectedGame)
self.view.selectRow(idx.row())
self.view.setFocus()
def loadGame(self):
"""load a game"""
selnum = len(self.selection.selectedRows())
if selnum != 1:
# should never happen
logException('loadGame: %d rows selected' % selnum)
idx = self.view.currentIndex()
self.selectedGame = self.model.record(idx.row()).value(0).toInt()[0]
self.buttonBox.accepted.emit()
def delete(self):
"""delete a game"""
def answered(result, games):
"""question answered, result is True or False"""
if result:
cmdList = []
for game in games:
cmdList.append("DELETE FROM score WHERE game = %d" % game)
cmdList.append("DELETE FROM game WHERE id = %d" % game)
Query(cmdList)
self.setQuery() # just reload entire table
deleteGames = list(x.data().toInt()[0]
for x in self.view.selectionModel().selectedRows(0))
if len(deleteGames) == 0:
# should never happen
logException('delete: 0 rows selected')
WarningYesNo(
m18n("Do you really want to delete <numid>%1</numid> games?<br>" \
"This will be final, you cannot cancel it with the cancel button",
len(deleteGames))).addCallback(answered, deleteGames)
def __createLayout(self):
""" Creates the dialog layout """
self.resize(700, 300)
self.setSizeGripEnabled(True)
layout = QVBoxLayout(self)
gridLayout = QGridLayout()
# Columns
colsLabel = QLabel("Columns")
self.__colsEdit = QLineEdit()
self.__colsEdit.setText(str(self.__settings.settings["COL_LIMIT"]))
self.__colsEdit.setToolTip(self.__settings.getDescription("COL_LIMIT"))
self.__colsEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(colsLabel, 0, 0, 1, 1)
gridLayout.addWidget(self.__colsEdit, 0, 1, 1, 1)
font = self.__colsEdit.font()
font.setFamily(GlobalData().skin.baseMonoFontFace)
self.__colsEdit.setFont(font)
# Assignment
assignmentLabel = QLabel("Assignment")
self.__assignmentEdit = QLineEdit()
self.__assignmentEdit.setText(self.__settings.settings["ASSIGNMENT"])
self.__assignmentEdit.setToolTip(
self.__settings.getDescription("ASSIGNMENT"))
self.__assignmentEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(assignmentLabel, 0, 3, 1, 1)
gridLayout.addWidget(self.__assignmentEdit, 0, 4, 1, 1)
self.__assignmentEdit.setFont(font)
# Function parameters assignment
funcAssignLabel = QLabel("Function params\nassignment")
self.__funcAssignEdit = QLineEdit()
self.__funcAssignEdit.setText(
self.__settings.settings["FUNCTION_PARAM_ASSIGNMENT"])
self.__funcAssignEdit.setToolTip(
self.__settings.getDescription("FUNCTION_PARAM_ASSIGNMENT"))
self.__funcAssignEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(funcAssignLabel, 1, 0, 1, 1)
gridLayout.addWidget(self.__funcAssignEdit, 1, 1, 1, 1)
self.__funcAssignEdit.setFont(font)
# Dictionary separator
dictSepLabel = QLabel("Dictionary separator")
self.__dictSepEdit = QLineEdit()
self.__dictSepEdit.setText(self.__settings.settings["DICT_COLON"])
self.__dictSepEdit.setToolTip(
self.__settings.getDescription("DICT_COLON"))
self.__dictSepEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(dictSepLabel, 1, 3, 1, 1)
gridLayout.addWidget(self.__dictSepEdit, 1, 4, 1, 1)
self.__dictSepEdit.setFont(font)
# Slice separator
sliceSepLabel = QLabel("Slice separator")
self.__sliceSepEdit = QLineEdit()
self.__sliceSepEdit.setText(self.__settings.settings["SLICE_COLON"])
self.__sliceSepEdit.setToolTip(
self.__settings.getDescription("SLICE_COLON"))
self.__sliceSepEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(sliceSepLabel, 2, 0, 1, 1)
gridLayout.addWidget(self.__sliceSepEdit, 2, 1, 1, 1)
self.__sliceSepEdit.setFont(font)
# Interpreter
inLabel = QLabel("Interpreter")
self.__inEdit = QLineEdit()
self.__inEdit.setText(self.__settings.settings["SHEBANG"])
self.__inEdit.setToolTip(self.__settings.getDescription("SHEBANG"))
self.__inEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(inLabel, 2, 3, 1, 1)
gridLayout.addWidget(self.__inEdit, 2, 4, 1, 1)
self.__inEdit.setFont(font)
# Coding spec
codingLabel = QLabel("Output encoding")
self.__outCodingEdit = QLineEdit()
self.__outCodingEdit.setText(self.__settings.settings["CODING"])
self.__outCodingEdit.setToolTip(
self.__settings.getDescription("CODING"))
self.__outCodingEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(codingLabel, 3, 0, 1, 1)
gridLayout.addWidget(self.__outCodingEdit, 3, 1, 1, 1)
self.__outCodingEdit.setFont(font)
# Src coding comment
srcCodingLabel = QLabel("File encoding\ncomment")
self.__srcCodingEdit = QLineEdit()
self.__srcCodingEdit.setText(self.__settings.settings["CODING_SPEC"])
self.__srcCodingEdit.setToolTip(
self.__settings.getDescription("CODING_SPEC"))
self.__srcCodingEdit.textChanged.connect(self.__validate)
gridLayout.addWidget(srcCodingLabel, 3, 3, 1, 1)
gridLayout.addWidget(self.__srcCodingEdit, 3, 4, 1, 1)
self.__srcCodingEdit.setFont(font)
layout.addLayout(gridLayout)
# Boilerplate
boilLabel = QLabel("Boilerplate ")
boilLabel.setAlignment(Qt.AlignTop)
self.__boilEdit = QTextEdit()
self.__boilEdit.setPlainText(self.__settings.settings["BOILERPLATE"])
self.__boilEdit.setToolTip(
self.__settings.getDescription("BOILERPLATE"))
self.__boilEdit.setTabChangesFocus(True)
self.__boilEdit.setAcceptRichText(False)
self.__boilEdit.setFont(font)
self.__boilEdit.textChanged.connect(self.__validate)
boilLayout = QHBoxLayout()
boilLayout.addWidget(boilLabel)
boilLayout.addWidget(self.__boilEdit)
layout.addLayout(boilLayout)
# Now check boxes and radio buttons
cbGridLayout = QGridLayout()
self.__keepBlanks = QCheckBox("Keep blank lines")
self.__keepBlanks.setChecked(
self.__settings.settings["KEEP_BLANK_LINES"])
self.__keepBlanks.setToolTip(
self.__settings.getDescription("KEEP_BLANK_LINES"))
cbGridLayout.addWidget(self.__keepBlanks, 0, 0, 1, 1)
self.__addBlanks = QCheckBox("Add blank lines around comments")
self.__addBlanks.setChecked(
self.__settings.settings["ADD_BLANK_LINES_AROUND_COMMENTS"])
self.__addBlanks.setToolTip(
self.__settings.getDescription("ADD_BLANK_LINES_AROUND_COMMENTS"))
cbGridLayout.addWidget(self.__addBlanks, 0, 2, 1, 1)
self.__justifyDoc = QCheckBox("Left justify doc strings")
self.__justifyDoc.setChecked(
self.__settings.settings["LEFTJUST_DOC_STRINGS"])
self.__justifyDoc.setToolTip(
self.__settings.getDescription("LEFTJUST_DOC_STRINGS"))
cbGridLayout.addWidget(self.__justifyDoc, 1, 0, 1, 1)
self.__wrapDoc = QCheckBox("Wrap long doc strings")
self.__wrapDoc.setChecked(self.__settings.settings["WRAP_DOC_STRINGS"])
self.__wrapDoc.setToolTip(
self.__settings.getDescription("WRAP_DOC_STRINGS"))
cbGridLayout.addWidget(self.__wrapDoc, 1, 2, 1, 1)
self.__recodeStrings = QCheckBox("Try to decode strings")
self.__recodeStrings.setChecked(
self.__settings.settings["RECODE_STRINGS"])
self.__recodeStrings.setToolTip(
self.__settings.getDescription("RECODE_STRINGS"))
cbGridLayout.addWidget(self.__recodeStrings, 2, 0, 1, 1)
self.__splitStrings = QCheckBox("Split long strings")
self.__splitStrings.setChecked(
self.__settings.settings["CAN_SPLIT_STRINGS"])
self.__splitStrings.setToolTip(
self.__settings.getDescription("CAN_SPLIT_STRINGS"))
cbGridLayout.addWidget(self.__splitStrings, 2, 2, 1, 1)
self.__keepUnassignedConst = QCheckBox("Keep unassigned constants")
self.__keepUnassignedConst.setChecked(
self.__settings.settings["KEEP_UNASSIGNED_CONSTANTS"])
self.__keepUnassignedConst.setToolTip(
self.__settings.getDescription("KEEP_UNASSIGNED_CONSTANTS"))
cbGridLayout.addWidget(self.__keepUnassignedConst, 3, 0, 1, 1)
self.__parenTuple = QCheckBox("Parenthesize tuple display")
self.__parenTuple.setChecked(
self.__settings.settings["PARENTHESIZE_TUPLE_DISPLAY"])
self.__parenTuple.setToolTip(
self.__settings.getDescription("PARENTHESIZE_TUPLE_DISPLAY"))
cbGridLayout.addWidget(self.__parenTuple, 3, 2, 1, 1)
self.__javaListDedent = QCheckBox("Java style list dedent")
self.__javaListDedent.setChecked(
self.__settings.settings["JAVA_STYLE_LIST_DEDENT"])
self.__javaListDedent.setToolTip(
self.__settings.getDescription("JAVA_STYLE_LIST_DEDENT"))
cbGridLayout.addWidget(self.__javaListDedent, 4, 0, 1, 1)
layout.addLayout(cbGridLayout)
# Quotes radio buttons
quotesGroupbox = QGroupBox("Quotes")
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth( \
quotesGroupbox.sizePolicy().hasHeightForWidth() )
quotesGroupbox.setSizePolicy(sizePolicy)
layoutQG = QVBoxLayout(quotesGroupbox)
self.__use1RButton = QRadioButton(
"Use apostrophes instead of quotes for string literals",
quotesGroupbox)
layoutQG.addWidget(self.__use1RButton)
self.__use2RButton = QRadioButton(
"Use quotes instead of apostrophes for string literals",
quotesGroupbox)
layoutQG.addWidget(self.__use2RButton)
self.__useAsIsRButton = QRadioButton("Do not make changes",
quotesGroupbox)
layoutQG.addWidget(self.__useAsIsRButton)
use1 = self.__settings.settings["SINGLE_QUOTED_STRINGS"]
use2 = self.__settings.settings["DOUBLE_QUOTED_STRINGS"]
if use1:
self.__use1RButton.setChecked(True)
elif use2:
self.__use2RButton.setChecked(True)
else:
self.__useAsIsRButton.setChecked(True)
layout.addWidget(quotesGroupbox)
fontMetrics = QFontMetrics(font)
editWidth = fontMetrics.width("iso8859-10 ") + 20
self.__colsEdit.setFixedWidth(editWidth)
self.__funcAssignEdit.setFixedWidth(editWidth)
self.__sliceSepEdit.setFixedWidth(editWidth)
self.__outCodingEdit.setFixedWidth(editWidth)
# Buttons at the bottom
buttonBox = QDialogButtonBox(self)
buttonBox.setOrientation(Qt.Horizontal)
buttonBox.setStandardButtons(QDialogButtonBox.Cancel)
self.__resetButton = buttonBox.addButton("Reset to Default",
QDialogButtonBox.ActionRole)
self.__resetButton.setToolTip(
"Mostly as recommended by PEP 8 / PEP 308")
self.__resetButton.clicked.connect(self.__reset)
self.__tidyButton = buttonBox.addButton("Tidy",
QDialogButtonBox.ActionRole)
self.__tidyButton.setToolTip("Save settings and run PythonTidy")
self.__tidyButton.setDefault(True)
self.__tidyButton.clicked.connect(self.__saveAndAccept)
layout.addWidget(buttonBox)
buttonBox.rejected.connect(self.close)
return
class XPopupWidget(QWidget):
""" """
Direction = enum('North', 'South', 'East', 'West')
Mode = enum('Popup', 'Dialog', 'ToolTip')
Anchor = enum('TopLeft', 'TopCenter', 'TopRight', 'LeftTop', 'LeftCenter',
'LeftBottom', 'RightTop', 'RightCenter', 'RightBottom',
'BottomLeft', 'BottomCenter', 'BottomRight')
aboutToShow = qt.Signal()
accepted = qt.Signal()
closed = qt.Signal()
rejected = qt.Signal()
resetRequested = qt.Signal()
shown = qt.Signal()
buttonClicked = qt.Signal(QAbstractButton)
def __init__(self, parent=None, buttons=None):
super(XPopupWidget, self).__init__(parent)
# define custom properties
self._anchor = XPopupWidget.Anchor.TopCenter
self._autoCalculateAnchor = False
self._autoCloseOnAccept = True
self._autoCloseOnReject = True
self._autoCloseOnFocusOut = False
self._autoDefault = True
self._first = True
self._animated = False
self._currentMode = None
self._positionLinkedTo = []
# define controls
self._resizable = True
self._popupPadding = 10
self._titleBarVisible = True
self._buttonBoxVisible = True
self._dialogButton = QToolButton(self)
self._closeButton = QToolButton(self)
self._scrollArea = QScrollArea(self)
self._sizeGrip = QSizeGrip(self)
self._sizeGrip.setFixedWidth(12)
self._sizeGrip.setFixedHeight(12)
self._leftSizeGrip = QSizeGrip(self)
self._leftSizeGrip.setFixedWidth(12)
self._leftSizeGrip.setFixedHeight(12)
if buttons is None:
buttons = QDialogButtonBox.NoButton
self._buttonBox = QDialogButtonBox(buttons, Qt.Horizontal, self)
self._buttonBox.setContentsMargins(3, 0, 3, 9)
self._scrollArea.setWidgetResizable(True)
self._scrollArea.setFrameShape(QScrollArea.NoFrame)
self._scrollArea.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
palette = self.palette()
self._scrollArea.setPalette(palette)
self._dialogButton.setToolTip('Popout to Dialog')
self._closeButton.setToolTip('Close Popup')
for btn in (self._dialogButton, self._closeButton):
btn.setAutoRaise(True)
btn.setIconSize(QSize(14, 14))
btn.setMaximumSize(16, 16)
# setup the icons
icon = QIcon(projexui.resources.find('img/dialog.png'))
self._dialogButton.setIcon(icon)
icon = QIcon(projexui.resources.find('img/close.png'))
self._closeButton.setIcon(icon)
# define the ui
hlayout = QHBoxLayout()
hlayout.setSpacing(0)
hlayout.addStretch(1)
hlayout.addWidget(self._dialogButton)
hlayout.addWidget(self._closeButton)
hlayout.setContentsMargins(0, 0, 0, 0)
hlayout2 = QHBoxLayout()
hlayout2.addWidget(self._buttonBox)
hlayout2.setContentsMargins(0, 0, 3, 0)
vlayout = QVBoxLayout()
vlayout.addLayout(hlayout)
vlayout.addWidget(self._scrollArea)
vlayout.addLayout(hlayout2)
vlayout.setContentsMargins(3, 2, 3, 2)
vlayout.setSpacing(0)
self.setLayout(vlayout)
self.setPositionLinkedTo(parent)
# set default properties
self.setAutoFillBackground(True)
self.setBackgroundRole(QPalette.Button)
self.setWindowTitle('Popup')
self.setFocusPolicy(Qt.StrongFocus)
self.setCurrentMode(XPopupWidget.Mode.Popup)
# create connections
self._dialogButton.clicked.connect(self.setDialogMode)
self._closeButton.clicked.connect(self.reject)
self._buttonBox.accepted.connect(self.accept)
self._buttonBox.rejected.connect(self.reject)
self._buttonBox.clicked.connect(self.handleButtonClick)
def addButton(self, button, role=QDialogButtonBox.ActionRole):
"""
Adds a custom button to the button box for this popup widget.
:param button | <QAbstractButton> || <str>
:return <button> || None (based on if a button or string was given)
"""
return self._buttonBox.addButton(button, role)
def adjustContentsMargins(self):
"""
Adjusts the contents for this widget based on the anchor and \
mode.
"""
anchor = self.anchor()
mode = self.currentMode()
# margins for a dialog
if (mode == XPopupWidget.Mode.Dialog):
self.setContentsMargins(0, 0, 0, 0)
# margins for a top anchor point
elif (anchor &
(XPopupWidget.Anchor.TopLeft | XPopupWidget.Anchor.TopCenter
| XPopupWidget.Anchor.TopRight)):
self.setContentsMargins(0, self.popupPadding() + 5, 0, 0)
# margins for a bottom anchor point
elif (
anchor &
(XPopupWidget.Anchor.BottomLeft | XPopupWidget.Anchor.BottomCenter
| XPopupWidget.Anchor.BottomRight)):
self.setContentsMargins(0, 0, 0, self.popupPadding())
# margins for a left anchor point
elif (anchor &
(XPopupWidget.Anchor.LeftTop | XPopupWidget.Anchor.LeftCenter
| XPopupWidget.Anchor.LeftBottom)):
self.setContentsMargins(self.popupPadding(), 0, 0, 0)
# margins for a right anchor point
else:
self.setContentsMargins(0, 0, self.popupPadding(), 0)
self.adjustMask()
def adjustMask(self):
"""
Updates the alpha mask for this popup widget.
"""
if self.currentMode() == XPopupWidget.Mode.Dialog:
self.clearMask()
return
path = self.borderPath()
bitmap = QBitmap(self.width(), self.height())
bitmap.fill(QColor('white'))
painter = QPainter()
painter.begin(bitmap)
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen(QColor('black'))
pen.setWidthF(0.75)
painter.setPen(pen)
painter.setBrush(QColor('black'))
painter.drawPath(path)
painter.end()
self.setMask(bitmap)
def adjustSize(self):
"""
Adjusts the size of this popup to best fit the new widget size.
"""
widget = self.centralWidget()
if widget is None:
super(XPopupWidget, self).adjustSize()
return
widget.adjustSize()
hint = widget.minimumSizeHint()
size = widget.minimumSize()
width = max(size.width(), hint.width())
height = max(size.height(), hint.height())
width += 20
height += 20
if self._buttonBoxVisible:
height += self.buttonBox().height() + 10
if self._titleBarVisible:
height += max(self._dialogButton.height(),
self._closeButton.height()) + 10
curr_w = self.width()
curr_h = self.height()
# determine if we need to move based on our anchor
anchor = self.anchor()
if anchor & (self.Anchor.LeftBottom | self.Anchor.RightBottom | \
self.Anchor.BottomLeft | self.Anchor.BottomCenter | \
self.Anchor.BottomRight):
delta_y = height - curr_h
elif anchor & (self.Anchor.LeftCenter | self.Anchor.RightCenter):
delta_y = (height - curr_h) / 2
else:
delta_y = 0
if anchor & (self.Anchor.RightTop | self.Anchor.RightCenter | \
self.Anchor.RightTop | self.Anchor.TopRight):
delta_x = width - curr_w
elif anchor & (self.Anchor.TopCenter | self.Anchor.BottomCenter):
delta_x = (width - curr_w) / 2
else:
delta_x = 0
self.setMinimumSize(width, height)
self.resize(width, height)
pos = self.pos()
pos.setX(pos.x() - delta_x)
pos.setY(pos.y() - delta_y)
self.move(pos)
@qt.Slot()
def accept(self):
"""
Emits the accepted signal and closes the popup.
"""
if not self.signalsBlocked():
self.accepted.emit()
if self.autoCloseOnAccept():
self.close()
def anchor(self):
"""
Returns the anchor point for this popup widget.
:return <XPopupWidget.Anchor>
"""
return self._anchor
def autoCalculateAnchor(self):
"""
Returns whether or not this popup should calculate the anchor point
on popup based on the parent widget and the popup point.
:return <bool>
"""
return self._autoCalculateAnchor
def autoCloseOnAccept(self):
"""
Returns whether or not this popup widget manages its own close on accept
behavior.
:return <bool>
"""
return self._autoCloseOnAccept
def autoCloseOnReject(self):
"""
Returns whether or not this popup widget manages its own close on reject
behavior.
:return <bool>
"""
return self._autoCloseOnReject
def autoCloseOnFocusOut(self):
"""
Returns whether or not this popup widget should auto-close when the user
clicks off the view.
:return <bool>
"""
return self._autoCloseOnFocusOut
def autoDefault(self):
"""
Returns whether or not clicking enter should default to the accept key.
:return <bool>
"""
return self._autoDefault
def borderPath(self):
"""
Returns the border path that will be drawn for this widget.
:return <QPainterPath>
"""
path = QPainterPath()
x = 1
y = 1
w = self.width() - 2
h = self.height() - 2
pad = self.popupPadding()
anchor = self.anchor()
# create a path for a top-center based popup
if anchor == XPopupWidget.Anchor.TopCenter:
path.moveTo(x, y + pad)
path.lineTo(x + ((w / 2) - pad), y + pad)
path.lineTo(x + (w / 2), y)
path.lineTo(x + ((w / 2) + pad), y + pad)
path.lineTo(x + w, y + pad)
path.lineTo(x + w, y + h)
path.lineTo(x, y + h)
path.lineTo(x, y + pad)
# create a path for a top-left based popup
elif anchor == XPopupWidget.Anchor.TopLeft:
path.moveTo(x, y + pad)
path.lineTo(x + pad, y)
path.lineTo(x + 2 * pad, y + pad)
path.lineTo(x + w, y + pad)
path.lineTo(x + w, y + h)
path.lineTo(x, y + h)
path.lineTo(x, y + pad)
# create a path for a top-right based popup
elif anchor == XPopupWidget.Anchor.TopRight:
path.moveTo(x, y + pad)
path.lineTo(x + w - 2 * pad, y + pad)
path.lineTo(x + w - pad, y)
path.lineTo(x + w, y + pad)
path.lineTo(x + w, y + h)
path.lineTo(x, y + h)
path.lineTo(x, y + pad)
# create a path for a bottom-left based popup
elif anchor == XPopupWidget.Anchor.BottomLeft:
path.moveTo(x, y)
path.lineTo(x + w, y)
path.lineTo(x + w, y + h - pad)
path.lineTo(x + 2 * pad, y + h - pad)
path.lineTo(x + pad, y + h)
path.lineTo(x, y + h - pad)
path.lineTo(x, y)
# create a path for a south based popup
elif anchor == XPopupWidget.Anchor.BottomCenter:
path.moveTo(x, y)
path.lineTo(x + w, y)
path.lineTo(x + w, y + h - pad)
path.lineTo(x + ((w / 2) + pad), y + h - pad)
path.lineTo(x + (w / 2), y + h)
path.lineTo(x + ((w / 2) - pad), y + h - pad)
path.lineTo(x, y + h - pad)
path.lineTo(x, y)
# create a path for a bottom-right based popup
elif anchor == XPopupWidget.Anchor.BottomRight:
path.moveTo(x, y)
path.lineTo(x + w, y)
path.lineTo(x + w, y + h - pad)
path.lineTo(x + w - pad, y + h)
path.lineTo(x + w - 2 * pad, y + h - pad)
path.lineTo(x, y + h - pad)
path.lineTo(x, y)
# create a path for a right-top based popup
elif anchor == XPopupWidget.Anchor.RightTop:
path.moveTo(x, y)
path.lineTo(x + w - pad, y)
path.lineTo(x + w, y + pad)
path.lineTo(x + w - pad, y + 2 * pad)
path.lineTo(x + w - pad, y + h)
path.lineTo(x, y + h)
path.lineTo(x, y)
# create a path for a right-center based popup
elif anchor == XPopupWidget.Anchor.RightCenter:
path.moveTo(x, y)
path.lineTo(x + w - pad, y)
path.lineTo(x + w - pad, y + ((h / 2) - pad))
path.lineTo(x + w, y + (h / 2))
path.lineTo(x + w - pad, y + ((h / 2) + pad))
path.lineTo(x + w - pad, y + h)
path.lineTo(x, y + h)
path.lineTo(x, y)
# create a path for a right-bottom based popup
elif anchor == XPopupWidget.Anchor.RightBottom:
path.moveTo(x, y)
path.lineTo(x + w - pad, y)
path.lineTo(x + w - pad, y + h - 2 * pad)
path.lineTo(x + w, y + h - pad)
path.lineTo(x + w - pad, y + h)
path.lineTo(x, y + h)
path.lineTo(x, y)
# create a path for a left-top based popup
elif anchor == XPopupWidget.Anchor.LeftTop:
path.moveTo(x + pad, y)
path.lineTo(x + w, y)
path.lineTo(x + w, y + h)
path.lineTo(x + pad, y + h)
path.lineTo(x + pad, y + 2 * pad)
path.lineTo(x, y + pad)
path.lineTo(x + pad, y)
# create a path for an left-center based popup
elif anchor == XPopupWidget.Anchor.LeftCenter:
path.moveTo(x + pad, y)
path.lineTo(x + w, y)
path.lineTo(x + w, y + h)
path.lineTo(x + pad, y + h)
path.lineTo(x + pad, y + ((h / 2) + pad))
path.lineTo(x, y + (h / 2))
path.lineTo(x + pad, y + ((h / 2) - pad))
path.lineTo(x + pad, y)
# create a path for a left-bottom based popup
elif anchor == XPopupWidget.Anchor.LeftBottom:
path.moveTo(x + pad, y)
path.lineTo(x + w, y)
path.lineTo(x + w, y + h)
path.lineTo(x + pad, y + h)
path.lineTo(x, y + h - pad)
path.lineTo(x + pad, y + h - 2 * pad)
path.lineTo(x + pad, y)
return path
def buttonBox(self):
"""
Returns the button box that is used to control this popup widget.
:return <QDialogButtonBox>
"""
return self._buttonBox
def centralWidget(self):
"""
Returns the central widget that is being used by this popup.
:return <QWidget>
"""
return self._scrollArea.widget()
def close(self):
"""
Closes the popup widget and central widget.
"""
widget = self.centralWidget()
if widget and not widget.close():
return
super(XPopupWidget, self).close()
def closeEvent(self, event):
widget = self.centralWidget()
if widget and not widget.close() and \
self.currentMode() != XPopupWidget.Mode.ToolTip:
event.ignore()
else:
super(XPopupWidget, self).closeEvent(event)
self.closed.emit()
def currentMode(self):
"""
Returns the current mode for this widget.
:return <XPopupWidget.Mode>
"""
return self._currentMode
@deprecatedmethod('XPopupWidget',
'Direction is no longer used, use anchor instead')
def direction(self):
"""
Returns the current direction parameter for this widget.
:return <XPopupWidget.Direction>
"""
anchor = self.anchor()
if (anchor &
(XPopupWidget.Anchor.TopLeft | XPopupWidget.Anchor.TopCenter
| XPopupWidget.Anchor.TopRight)):
return XPopupWidget.Direction.North
elif (
anchor &
(XPopupWidget.Anchor.BottomLeft | XPopupWidget.Anchor.BottomCenter
| XPopupWidget.Anchor.BottomRight)):
return XPopupWidget.Direction.South
elif (anchor &
(XPopupWidget.Anchor.LeftTop | XPopupWidget.Anchor.LeftCenter
| XPopupWidget.Anchor.LeftBottom)):
return XPopupWidget.Direction.East
else:
return XPopupWidget.Direction.West
def eventFilter(self, object, event):
"""
Processes when the window is moving to update the position for the
popup if in popup mode.
:param object | <QObject>
event | <QEvent>
"""
links = self.positionLinkedTo()
is_dialog = self.currentMode() == self.Mode.Dialog
if object not in links:
return False
if event.type() == event.Close:
self.close()
return False
if event.type() == event.Hide and not is_dialog:
self.hide()
return False
if event.type() == event.Move and not is_dialog:
deltaPos = event.pos() - event.oldPos()
self.move(self.pos() + deltaPos)
return False
if self.currentMode() != self.Mode.ToolTip:
return False
if event.type() == event.Leave:
pos = object.mapFromGlobal(QCursor.pos())
if (not object.rect().contains(pos)):
self.close()
event.accept()
return True
if event.type() in (event.MouseButtonPress, event.MouseButtonDblClick):
self.close()
event.accept()
return True
return False
@qt.Slot(QAbstractButton)
def handleButtonClick(self, button):
"""
Handles the button click for this widget. If the Reset button was
clicked, then the resetRequested signal will be emitted. All buttons
will emit the buttonClicked signal.
:param button | <QAbstractButton>
"""
if (self.signalsBlocked()):
return
if (button == self._buttonBox.button(QDialogButtonBox.Reset)):
self.resetRequested.emit()
self.buttonClicked.emit(button)
def isAnimated(self):
"""
Returns whether or not the popup widget should animate its opacity
when it is shown.
:return <bool>
"""
return self._animated
def isResizable(self):
"""
Returns if this popup is resizable or not.
:return <bool>
"""
return self._resizable
def keyPressEvent(self, event):
"""
Looks for the Esc key to close the popup.
:param event | <QKeyEvent>
"""
if (event.key() == Qt.Key_Escape):
self.reject()
event.accept()
return
elif (event.key() in (Qt.Key_Return, Qt.Key_Enter)):
if self._autoDefault:
self.accept()
event.accept()
return
super(XPopupWidget, self).keyPressEvent(event)
def mapAnchorFrom(self, widget, globalPos):
"""
Returns the anchor point that best fits within the given widget from
the inputed global position.
:param widget | <QWidget>
globalPos | <QPoint>
:return <XPopupWidget.Anchor>
"""
localPos = widget.mapFromGlobal(globalPos)
x = localPos.x()
y = localPos.y()
w = widget.width()
h = widget.height()
cw = self.width() / 2
ch = self.height() / 2
# by default, try to do a center point, so make sure the center point
# is at least 1/2 the width longer from each edge
if x < cw and h - y < ch:
return XPopupWidget.Anchor.BottomLeft
elif x < cw:
return XPopupWidget.Anchor.TopLeft
elif w - x < cw and h - y < ch:
return XPopupWidget.Anchor.BottomRight
elif w - x < cw:
return XPopupWidget.Anchor.TopRight
elif h - y < ch:
return XPopupWidget.Anchor.BottomCenter
else:
return XPopupWidget.Anchor.TopCenter
def popup(self, pos=None):
"""
Pops up this widget at the inputed position. The inputed point should \
be in global space.
:param pos | <QPoint>
:return <bool> success
"""
if self._first and self.centralWidget() is not None:
self.adjustSize()
self._first = False
if not self.signalsBlocked():
self.aboutToShow.emit()
if not pos:
pos = QCursor.pos()
if self.currentMode() == XPopupWidget.Mode.Dialog and \
self.isVisible():
return False
elif self.currentMode() == XPopupWidget.Mode.Dialog:
self.setPopupMode()
# auto-calculate the point
if self.autoCalculateAnchor():
self.setAnchor(self.mapAnchorFrom(self.parent(), pos))
pad = self.popupPadding()
# determine where to move based on the anchor
anchor = self.anchor()
# MODIFY X POSITION
# align x-left
if (anchor &
(XPopupWidget.Anchor.TopLeft | XPopupWidget.Anchor.BottomLeft)):
pos.setX(pos.x() - pad)
# align x-center
elif (anchor & (XPopupWidget.Anchor.TopCenter
| XPopupWidget.Anchor.BottomCenter)):
pos.setX(pos.x() - self.width() / 2)
# align x-right
elif (
anchor &
(XPopupWidget.Anchor.TopRight | XPopupWidget.Anchor.BottomRight)):
pos.setX(pos.x() - self.width() + pad)
# align x-padded
elif (anchor &
(XPopupWidget.Anchor.RightTop | XPopupWidget.Anchor.RightCenter
| XPopupWidget.Anchor.RightBottom)):
pos.setX(pos.x() - self.width())
# MODIFY Y POSITION
# align y-top
if (anchor &
(XPopupWidget.Anchor.LeftTop | XPopupWidget.Anchor.RightTop)):
pos.setY(pos.y() - pad)
# align y-center
elif (anchor & (XPopupWidget.Anchor.LeftCenter
| XPopupWidget.Anchor.RightCenter)):
pos.setY(pos.y() - self.height() / 2)
# align y-bottom
elif (anchor & (XPopupWidget.Anchor.LeftBottom
| XPopupWidget.Anchor.RightBottom)):
pos.setY(pos.y() - self.height() + pad)
# align y-padded
elif (
anchor &
(XPopupWidget.Anchor.BottomLeft | XPopupWidget.Anchor.BottomCenter
| XPopupWidget.Anchor.BottomRight)):
pos.setY(pos.y() - self.height())
self.adjustMask()
self.move(pos)
self.update()
self.setUpdatesEnabled(True)
if self.isAnimated():
anim = QPropertyAnimation(self, 'windowOpacity')
anim.setParent(self)
anim.setStartValue(0.0)
anim.setEndValue(self.windowOpacity())
anim.setDuration(500)
anim.finished.connect(anim.deleteLater)
self.setWindowOpacity(0.0)
else:
anim = None
self.show()
if self.currentMode() != XPopupWidget.Mode.ToolTip:
self.activateWindow()
widget = self.centralWidget()
if widget:
self.centralWidget().setFocus()
if anim:
anim.start()
if not self.signalsBlocked():
self.shown.emit()
return True
def paintEvent(self, event):
"""
Overloads the paint event to handle painting pointers for the popup \
mode.
:param event | <QPaintEvent>
"""
# use the base technique for the dialog mode
if self.currentMode() == XPopupWidget.Mode.Dialog:
super(XPopupWidget, self).paintEvent(event)
return
# setup the coloring options
palette = self.palette()
painter = QPainter()
painter.begin(self)
pen = QPen(palette.color(palette.Window).darker(130))
pen.setWidthF(1.75)
painter.setPen(pen)
painter.setRenderHint(painter.Antialiasing)
painter.setBrush(palette.color(palette.Window))
painter.drawPath(self.borderPath())
painter.end()
def popupPadding(self):
"""
Returns the amount of pixels to pad the popup arrow for this widget.
:return <int>
"""
return self._popupPadding
def positionLinkedTo(self):
"""
Returns the widget that this popup is linked to for positional changes.
:return [<QWidget>, ..]
"""
return self._positionLinkedTo
@qt.Slot()
def reject(self):
"""
Emits the accepted signal and closes the popup.
"""
if not self.signalsBlocked():
self.rejected.emit()
if self.autoCloseOnReject():
self.close()
def resizeEvent(self, event):
"""
Resizes this widget and updates the mask.
:param event | <QResizeEvent>
"""
self.setUpdatesEnabled(False)
super(XPopupWidget, self).resizeEvent(event)
self.adjustMask()
self.setUpdatesEnabled(True)
x = self.width() - self._sizeGrip.width()
y = self.height() - self._sizeGrip.height()
self._leftSizeGrip.move(0, y)
self._sizeGrip.move(x, y)
def scrollArea(self):
"""
Returns the scroll area widget for this popup.
:return <QScrollArea>
"""
return self._scrollArea
def setAnimated(self, state):
"""
Sets whether or not the popup widget should animate its opacity
when it is shown.
:param state | <bool>
"""
self._animated = state
self.setAttribute(Qt.WA_TranslucentBackground, state)
def setAutoCloseOnAccept(self, state):
"""
Sets whether or not the popup handles closing for accepting states.
:param state | <bool>
"""
self._autoCloseOnAccept = state
def setAutoCloseOnReject(self, state):
"""
Sets whether or not the popup handles closing for rejecting states.
:param state | <bool>
"""
self._autoCloseOnReject = state
def setAutoDefault(self, state):
"""
Sets whether or not the buttons should respond to defaulting options
when the user is interacting with it.
:param state | <bool>
"""
self._autoDefault = state
for button in self.buttonBox().buttons():
button.setAutoDefault(state)
button.setDefault(state)
def setAnchor(self, anchor):
"""
Sets the anchor position for this popup widget to the inputed point.
:param anchor | <XPopupWidget.Anchor>
"""
self._anchor = anchor
self.adjustContentsMargins()
def setAutoCalculateAnchor(self, state):
"""
Sets whether or not this widget should auto-calculate the anchor point
based on the parent position when the popup is triggered.
:param state | <bool>
"""
self._autoCalculateAnchor = state
def setAutoCloseOnFocusOut(self, state):
"""
Sets whether or not this popup widget should auto-close when the user
clicks off the view.
:param state | <bool>
"""
self._autoCloseOnFocusOut = state
self.updateModeSettings()
def setCentralWidget(self, widget):
"""
Sets the central widget that will be used by this popup.
:param widget | <QWidget> || None
"""
self._scrollArea.takeWidget()
self._scrollArea.setWidget(widget)
self.adjustSize()
def setCurrentMode(self, mode):
"""
Sets the current mode for this dialog to the inputed mode.
:param mode | <XPopupWidget.Mode>
"""
if (self._currentMode == mode):
return
self._currentMode = mode
self.updateModeSettings()
@qt.Slot()
def setDialogMode(self):
"""
Sets the current mode value to Dialog.
"""
self.setCurrentMode(XPopupWidget.Mode.Dialog)
@deprecatedmethod('XPopupWidget',
'Direction is no longer used, use setAnchor instead')
def setDirection(self, direction):
"""
Sets the direction for this widget to the inputed direction.
:param direction | <XPopupWidget.Direction>
"""
if (direction == XPopupWidget.Direction.North):
self.setAnchor(XPopupWidget.Anchor.TopCenter)
elif (direction == XPopupWidget.Direction.South):
self.setAnchor(XPopupWidget.Anchor.BottomCenter)
elif (direction == XPopupWidget.Direction.East):
self.setAnchor(XPopupWidget.Anchor.LeftCenter)
else:
self.setAnchor(XPopupWidget.Anchor.RightCenter)
def setPalette(self, palette):
"""
Sets the palette for this widget and the scroll area.
:param palette | <QPalette>
"""
super(XPopupWidget, self).setPalette(palette)
self._scrollArea.setPalette(palette)
def setPopupMode(self):
"""
Sets the current mode value to Popup.
"""
self.setCurrentMode(XPopupWidget.Mode.Popup)
def setPopupPadding(self, padding):
"""
Sets the amount to pad the popup area when displaying this widget.
:param padding | <int>
"""
self._popupPadding = padding
self.adjustContentsMargins()
def setPositionLinkedTo(self, widgets):
"""
Sets the widget that this popup will be linked to for positional
changes.
:param widgets | <QWidget> || [<QWidget>, ..]
"""
if type(widgets) in (list, set, tuple):
new_widgets = list(widgets)
else:
new_widgets = []
widget = widgets
while widget:
widget.installEventFilter(self)
new_widgets.append(widget)
widget = widget.parent()
self._positionLinkedTo = new_widgets
def setResizable(self, state):
self._resizable = state
self._sizeGrip.setVisible(state)
self._leftSizeGrip.setVisible(state)
def setShowButtonBox(self, state):
self._buttonBoxVisible = state
self.buttonBox().setVisible(state)
def setShowTitleBar(self, state):
self._titleBarVisible = state
self._dialogButton.setVisible(state)
self._closeButton.setVisible(state)
def setToolTipMode(self):
"""
Sets the mode for this popup widget to ToolTip
"""
self.setCurrentMode(XPopupWidget.Mode.ToolTip)
def setVisible(self, state):
super(XPopupWidget, self).setVisible(state)
widget = self.centralWidget()
if widget:
widget.setVisible(state)
def timerEvent(self, event):
"""
When the timer finishes, hide the tooltip popup widget.
:param event | <QEvent>
"""
if self.currentMode() == XPopupWidget.Mode.ToolTip:
self.killTimer(event.timerId())
event.accept()
self.close()
else:
super(XPopupWidget, self).timerEvent(event)
def updateModeSettings(self):
mode = self.currentMode()
is_visible = self.isVisible()
# display as a floating dialog
if mode == XPopupWidget.Mode.Dialog:
self.setWindowFlags(Qt.Dialog | Qt.Tool)
self.setAttribute(Qt.WA_TransparentForMouseEvents, False)
self._closeButton.setVisible(False)
self._dialogButton.setVisible(False)
# display as a user tooltip
elif mode == XPopupWidget.Mode.ToolTip:
flags = Qt.Popup | Qt.FramelessWindowHint
self.setWindowFlags(flags)
self.setBackgroundRole(QPalette.Window)
self.setAttribute(Qt.WA_TransparentForMouseEvents)
self.setShowTitleBar(False)
self.setShowButtonBox(False)
self.setFocusPolicy(Qt.NoFocus)
# hide the scrollbars
policy = Qt.ScrollBarAlwaysOff
self._scrollArea.setVerticalScrollBarPolicy(policy)
self._scrollArea.setHorizontalScrollBarPolicy(policy)
# display as a popup widget
else:
flags = Qt.Popup | Qt.FramelessWindowHint
if not self.autoCloseOnFocusOut():
flags |= Qt.Tool
self.setWindowFlags(flags)
self._closeButton.setVisible(self._titleBarVisible)
self._dialogButton.setVisible(self._titleBarVisible)
self.setBackgroundRole(QPalette.Button)
self.adjustContentsMargins()
if (is_visible):
self.show()
@staticmethod
@deprecatedmethod('XPopupWidget',
'This method no longer has an effect as we are not '\
'storing references to the tooltip.')
def hideToolTip(key=None):
"""
Hides any existing tooltip popup widgets.
:warning This method is deprecated!
"""
pass
@staticmethod
def showToolTip(text,
point=None,
anchor=None,
parent=None,
background=None,
foreground=None,
key=None,
seconds=5):
"""
Displays a popup widget as a tooltip bubble.
:param text | <str>
point | <QPoint> || None
anchor | <XPopupWidget.Mode.Anchor> || None
parent | <QWidget> || None
background | <QColor> || None
foreground | <QColor> || None
key | <str> || None
seconds | <int>
"""
if point is None:
point = QCursor.pos()
if parent is None:
parent = QApplication.activeWindow()
if anchor is None and parent is None:
anchor = XPopupWidget.Anchor.TopCenter
# create a new tooltip widget
widget = XPopupWidget(parent)
widget.setToolTipMode()
widget.setResizable(False)
# create the tooltip label
label = QLabel(text, widget)
label.setOpenExternalLinks(True)
label.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
label.setMargin(3)
label.setIndent(3)
label.adjustSize()
widget.setCentralWidget(label)
# update the tip
label.adjustSize()
widget.adjustSize()
palette = widget.palette()
if not background:
background = palette.color(palette.ToolTipBase)
if not foreground:
foreground = palette.color(palette.ToolTipText)
palette.setColor(palette.Window, QColor(background))
palette.setColor(palette.WindowText, QColor(foreground))
widget.setPalette(palette)
widget.centralWidget().setPalette(palette)
if anchor is None:
widget.setAutoCalculateAnchor(True)
else:
widget.setAnchor(anchor)
widget.setAutoCloseOnFocusOut(True)
widget.setAttribute(Qt.WA_DeleteOnClose)
widget.popup(point)
widget.startTimer(1000 * seconds)
return widget
