def build_filter_display(self):
"""Creates Filter UI"""
filter_txt = QLineEdit(self)
filter_txt.setReadOnly(False)
filter_txt.setText('date:today')
filter_txt.setFocus()
filter_txt.textChanged.connect(self.filter_notes)
filter_txt.returnPressed.connect(self.filter_notes)
filter_txt.setStyleSheet("border: 0px;")
filter_txt.setToolTip("Filter Input")
self.filter_txt = filter_txt
completer = QCompleter(
self.connection_manager.get_primary_connector().get_common_words())
completer.setCompletionMode(QCompleter.PopupCompletion)
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setModelSorting(QCompleter.CaseInsensitivelySortedModel)
completer.popup().setStyleSheet("""
QListView {
background-color: #272822;
color: #aaa;
selection-background-color: #511;
}
""")
filter_txt.setCompleter(completer)
class ExtendedComboBox(QComboBox):
def __init__(self):
QComboBox.__init__(self)
self.setFocusPolicy(Qt.StrongFocus)
self.setEditable(True)
self.filter_model = QSortFilterProxyModel(self)
self.filter_model.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.filter_model.setSourceModel(self.model())
self.completer = QCompleter(self.filter_model, self)
self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.setCompleter(self.completer)
self.lineEdit().textEdited.connect(
self.filter_model.setFilterFixedString)
self.completer.activated.connect(self.on_completer_activated)
def on_completer_activated(self, text):
if text:
index = self.findText(text)
self.setCurrentIndex(index)
self.activated[str].emit(self.itemText(index))
def setModel(self, model):
self.setModel(model)
self.filter_model.setSourceModel(model)
self.completer.setModel(self.filter_model)
def setModelColumn(self, column):
self.completer.setCompletionColumn(column)
self.filter_model.setFilterKeyColumn(column)
self.setModelColumn(column)
def dropdiam(self):
conn = connectSQLite()
cur = conn.cursor()
try:
###################this is different from filled ############
if (self.LE_Diam is not None or self.LE_Diam != ""):
self.LE_Diam.clear()
#############
description = self.LE_DescMat.text()
cur.execute(
"SELECT Diam FROM Mat WHERE Name = ? ORDER BY Diam ASC",
(description, ))
desc = cur.fetchall()
listdesc = []
for dsc in desc:
for d in dsc:
listdesc.append(str(d))
cmpt = QCompleter(listdesc)
cmpt.setCaseSensitivity(0)
cmpt.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.LE_Diam.setCompleter(cmpt)
self.LE_Diam.editingFinished.connect(self.remplircodemat)
except:
QMessageBox.about(
self, "Warning",
"Error. Not matching material designation. Please select a designation proposed in the dropdown list. "
)
closeSQLite(conn)
class Autocomplete(QComboBox):
def __init__(self, parent = None):
super(Autocomplete, self).__init__(parent)
self.setFocusPolicy(Qt.StrongFocus)
self.setEditable(True)
# add a filter model to filter matching items
self.pFilterModel = QSortFilterProxyModel(self)
self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.pFilterModel.setSourceModel(self.model())
# add a completer, which uses the filter model
self.completer = QCompleter(self.pFilterModel, self)
# always show all (filtered) completions
self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.setCompleter(self.completer)
self.resize(500, 30)
# connect signals
def filter(text):
self.pFilterModel.setFilterFixedString(str(text))
self.lineEdit().textEdited.connect(filter)
self.completer.activated.connect(self.on_completer_activated)
# on selection of an item from the completer, select the corresponding item from combobox
def on_completer_activated(self, text):
if text:
index = self.findText(str(text))
self.setCurrentIndex(index)
def __init__(self, parent):
super(VueMaterialManagement, self).__init__(parent)
self.setupUi(self)
self.PB_SetAllCost.clicked.connect(self.setall)
self.PB_SetFromTo.clicked.connect(self.setfromto)
self.PB_EnterMat.clicked.connect(self.remplirmat)
self.PB_NewRawMat.clicked.connect(self.addrawmat)
self.PB_ShowAll.clicked.connect(self.showAllMat)
conn = connectSQLite()
cur = conn.cursor()
cur.execute("SELECT DISTINCT Name FROM Mat ORDER BY Name ASC")
name = cur.fetchall()
listnum = []
for prt in name:
for p in prt:
listnum.append(str(p))
cmpt = QCompleter(listnum)
cmpt.setCaseSensitivity(0)
cmpt.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.LE_MatName.setCompleter(cmpt)
cur.execute("SELECT MAX(Number) FROM Mat")
number = cur.fetchone()
nextnumber = str(number[0] + 1)
self.LE_RawNumber.setText(nextnumber)
closeSQLite(conn)
def add_compliter_line_field(self,
f_title,
top,
left,
items,
default_value,
widthchange=0,
readonly=False,
label_margin=2,
label_font_size=LABEL_FONT_SIZE,
field_size=4,
callback=None):
# make line edit field with compliter, including items
field = self.add_line_field(f_title,
top,
left,
default_value,
widthchange,
readonly,
label_margin=label_margin,
label_font_size=label_font_size,
field_size=field_size)
compliter = QCompleter(items)
compliter.setCaseSensitivity(0)
compliter.setCompletionMode(0)
q = compliter.filterMode()
compliter.setFilterMode(Qt.MatchContains)
field.setCompleter(compliter)
if callback:
field.editingFinished.connect(callback)
return field
def __init__(self, parent):
super(CommandPalette, self).__init__()
# set parent and various properties
self.setParent(parent)
self.setWindowFlags(Qt.FramelessWindowHint | Qt.Dialog)
self.resize(300, 30)
self.hal = parent
# bind ctrl+P to close
ctrlP = QShortcut(QKeySequence("Ctrl+P"), self)
ctrlP.activated.connect(self.reject)
# setup layout
layout = QVBoxLayout(self)
# add the command palette input
cmdline = QLineEdit(self)
layout.addWidget(cmdline)
self.cmdline = cmdline
# connect callback
cmdline.returnPressed.connect(self.accept)
# setup completer
command_list = sorted(parent.palette_commands.keys())
autoCompleter = QCompleter(command_list, self)
autoCompleter.setCaseSensitivity(Qt.CaseInsensitive)
autoCompleter.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
autoCompleter.setFilterMode(Qt.MatchContains)
cmdline.setCompleter(autoCompleter)
def updateMapCompleters(self):
"""Update the auto completers for maps."""
for i in range(self.max_no_sets):
map_list = scctool.settings.maps.copy()
try:
map_list.remove("TBD")
except Exception:
pass
finally:
map_list.sort()
map_list.append("TBD")
completer = QCompleter(map_list, self.le_map[i])
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setFilterMode(Qt.MatchContains)
completer.setCompletionMode(
QCompleter.UnfilteredPopupCompletion)
completer.setWrapAround(True)
completer.activated.connect(self.le_map[i].completerFinished)
self.le_map[i].setCompleter(completer)
for i in range(self.max_no_vetoes):
map_list = scctool.settings.maps.copy()
if 'TBD' in map_list:
map_list.remove('TBD')
map_list.sort()
map_list.append('TBD')
completer = QCompleter(map_list, self.le_veto_maps[i])
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setFilterMode(Qt.MatchContains)
completer.setCompletionMode(
QCompleter.UnfilteredPopupCompletion)
completer.setWrapAround(True)
completer.activated.connect(self.le_veto_maps[i].completerFinished)
self.le_veto_maps[i].setCompleter(completer)
def __init__(self):
super().__init__()
completer = QCompleter(Context.cardboard_names)
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setFilterMode(Qt.MatchStartsWith)
completer.setModelSorting(QCompleter.CaseInsensitivelySortedModel)
completer.setCompletionMode(QCompleter.InlineCompletion)
self.setCompleter(completer)
class ExtendedComboBox(QComboBox):
"""An enhanced version of PyQt5's QComboBox widget that allows for search
and filtering of the greater list. Implemented by armonge on StackOverflow,
adapted for PyQt5 by Tamas Haver on StackOverflow.
The Stackoverflow post can be found here:
https://stackoverflow.com/questions/4827207/how-do-i-filter-the-pyqt-qcombobox-items-based-on-the-text-input
"""
def __init__(self, parent=None):
super(ExtendedComboBox, self).__init__(parent)
self.setFocusPolicy(QtCore.Qt.StrongFocus)
self.setEditable(True)
# add a filter model to filter matching items
self.pFilterModel = QtCore.QSortFilterProxyModel(self)
self.pFilterModel.setFilterCaseSensitivity(QtCore.Qt.CaseInsensitive)
self.pFilterModel.setSourceModel(self.model())
# add a completer, which uses the filter model
self.completer = QCompleter(self.pFilterModel, self)
# always show all (filtered) completions
self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.setCompleter(self.completer)
# connect signals
self.lineEdit().textEdited.connect(
self.pFilterModel.setFilterFixedString)
self.completer.activated.connect(self.on_completer_activated)
def on_completer_activated(self, text):
"""On selection of an item from the completer, select the corresponding
item from combobox.
"""
if text:
index = self.findText(text)
self.setCurrentIndex(index)
self.activated[str].emit(self.itemText(index))
def setModel(self, model):
"""On model change, update the models of the filter and completer as
well.
"""
super(ExtendedComboBox, self).setModel(model)
self.pFilterModel.setSourceModel(model)
self.completer.setModel(self.pFilterModel)
def setModelColumn(self, column):
"""On model column change, update the model column of the filter and
completer as well.
"""
self.completer.setCompletionColumn(column)
self.pFilterModel.setFilterKeyColumn(column)
super(ExtendedComboBox, self).setModelColumn(column)
def __init__(self, *args, **kwargs):
super(DirLineEdit, self).__init__(*args, **kwargs)
completer = QCompleter()
completer.setCompletionMode(QCompleter.PopupCompletion)
dirfilter = QDir.AllEntries | QDir.NoDotAndDotDot | QDir.Hidden
sortflags = QDir.DirsFirst | QDir.IgnoreCase
dirmodel = QDirModel(['*'], dirfilter, sortflags, completer)
completer.setModel(dirmodel)
self.setCompleter(completer)
class ExtendedCombo(QComboBox):
def __init__(self, items=None, parent=None):
super().__init__(parent)
self.setFocusPolicy(Qt.StrongFocus)
self.setEditable(True)
self.completer = QCompleter(self)
# always show all completions
self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.pFilterModel = QSortFilterProxyModel(self)
self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.completer.setPopup(self.view())
self.setCompleter(self.completer)
self.lineEdit().textEdited.connect(self.pFilterModel.setFilterFixedString)
self.completer.activated.connect(self.setTextIfCompleterIsClicked)
def setItems(self, items: list or set):
self.items = list(items)
model = QStandardItemModel()
for i, student in enumerate(items):
item = UserItem(student)
model.setItem(i, 0, item)
self.setModel(model)
self.setModelColumn(0)
def setModel(self, model):
super(ExtendedCombo, self).setModel(model)
self.pFilterModel.setSourceModel(model)
self.completer.setModel(self.pFilterModel)
def setModelColumn(self, column):
self.completer.setCompletionColumn(column)
self.pFilterModel.setFilterKeyColumn(column)
super(ExtendedCombo, self).setModelColumn(column)
def view(self):
return self.completer.popup()
def index(self):
return self.currentIndex()
def setTextIfCompleterIsClicked(self, text):
if text:
index = self.findText(text)
self.setCurrentIndex(index)
def currentItem(self):
return self.items[self.currentIndex()]
class SQLiteCompleterText(QTextEdit):
def __init__(self, parent=None):
super(SQLiteCompleterText, self).__init__(parent)
self.cp = QCompleter(words)
self.cp.setWrapAround(False)
self.cp.setWidget(self)
self.cp.setCompletionMode(QCompleter.PopupCompletion)
self.cp.activated.connect(self.insertCompletion)
def insertCompletion(self, completion):
tc = self.textCursor()
extra = len(completion) - len(self.cp.completionPrefix())
tc.movePosition(QTextCursor.Left)
tc.movePosition(QTextCursor.EndOfWord)
tc.insertText(completion[-extra:])
self.setTextCursor(tc)
def textUnderCursor(self):
tc = self.textCursor()
tc.select(QTextCursor.WordUnderCursor)
return tc.selectedText()
def focusInEvent(self, e):
self.cp.setWidget(self)
super(SQLiteCompleterText, self).focusInEvent(e)
def keyPressEvent(self, e):
if self.cp.popup().isVisible():
if e.key() in (Qt.Key_Enter, Qt.Key_Return, Qt.Key_Escape, Qt.Key_Tab, Qt.Key_Backtab):
e.ignore()
return
is_shortcut = ((e.modifiers() & Qt.ControlModifier) != 0 and e.key() == Qt.Key_E & Qt.ControlModifier)
if not is_shortcut:
super(SQLiteCompleterText, self).keyPressEvent(e)
ctrl_or_shift = e.modifiers() & (Qt.ControlModifier | Qt.ShiftModifier)
if ctrl_or_shift and len(e.text()) == 0:
return
eo = "~!@#$%^&*()_+{}|:\"<>?,./;'[]\\-="
has_modifier = (e.modifiers() != Qt.NoModifier) and not ctrl_or_shift
cp = self.textUnderCursor()
if not is_shortcut and (cp in words or has_modifier or len(e.text()) == 0 or len(cp) < 1 or e.text()[-1] in eo):
self.cp.popup().hide()
return
if cp != self.cp.completionPrefix():
self.cp.setCompletionPrefix(cp)
self.cp.popup().setCurrentIndex(self.cp.completionModel().index(0, 0))
cr = self.cursorRect()
cr.setWidth(self.cp.popup().sizeHintForColumn(0) + self.cp.popup().verticalScrollBar().sizeHint().width())
self.cp.complete(cr)
def __init__(self):
super(FTPWindow, self).__init__()
#connect to FTP server.
self.connect_ftp()
#setup UI from Qt Designer.
self.setupUi(self)
#display welcome from ftp server.
#self.lbl_connection.setText(self.ftp.getwelcome())
#get a list of files for James to choose from and put them in
#a combo box.
files = self.get_file_list()
self.cb_files.addItems(files)
self.cb_upd_files.addItems(files)
self.cb_cross_files.addItems(files)
#setup a auto completer to choose campaign files from.
campaigns = self.get_campaigns()
camp_completer = QCompleter(campaigns)
camp_completer.setCompletionMode(QCompleter.InlineCompletion)
camp_completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
camp_completer.setCaseSensitivity(Qt.CaseInsensitive)
#we have to styple this here instead of Qt Designer, becuase for some reason there is no way
#to style the popup using css.
camp_completer.popup().setStyleSheet(
"""selection-background-color: #ffaa00;
background-color: QLinearGradient( x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #565656, stop: 0.1 #525252, stop: 0.5 #4e4e4e, stop: 0.9 #4a4a4a, stop: 1 #464646);
border-style: solid;
border: 1px solid #1e1e1e;
border-radius: 5;""")
self.le_campaign.setCompleter(camp_completer)
#connect the button signals with the appropriate slots.
self.btn_dl_match.clicked.connect(self.btn_download_clicked)
self.btn_match.clicked.connect(self.btn_match_clicked)
self.btn_dl_update.clicked.connect(self.btn_download_clicked)
self.btn_dl_cc.clicked.connect(self.btn_download_clicked)
self.btn_google.clicked.connect(self.btn_google_clicked)
self.actionExit.triggered.connect(qApp.instance().exit)
max_date = self.get_last_google_import()
self.start_dt = max_date + timedelta(days=1)
self.end_dt = datetime.now() - timedelta(days=1)
#self.de_ga_start.setDateTime(datetime.now() - timedelta(days=13))
self.de_ga_start.setDateTime(self.start_dt)
self.de_ga_end.setDateTime(self.end_dt)
self.de_ga_start.dateChanged.connect(self.date_changed)
self.de_ga_end.dateChanged.connect(self.date_changed)
self.btn_view_ga_tbl.clicked.connect(self.view_table)
def updatePlayerCompleters(self):
"""Refresh the completer for the player line edits."""
list = ["TBD"] + self.controller.historyManager.getPlayerList()
for player_idx in range(self.max_no_sets):
for team_idx in range(2):
completer = QCompleter(list,
self.le_player[team_idx][player_idx])
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setCompletionMode(QCompleter.InlineCompletion)
completer.setWrapAround(True)
self.le_player[team_idx][player_idx].setCompleter(completer)
class LineEditWithComplete(QLineEdit):
def __init__(self,
parent,
inputList,
configPath='./config/LineEditWithHistory.ini',
qssFilePath="./Resources/stylesheet/style.qss"):
super(LineEditWithComplete, self).__init__(parent)
self.qssFilePath = qssFilePath
self.configPath = configPath
# 用于存放历史记录的List
self.inputList = inputList
self.__widgetInit()
def Exit(self):
pass
def __widgetInit(self):
# LineEdit设置QCompleter，用于显示历史记录
self.completer = QCompleter(self)
self.listModel = QStringListModel(self.inputList, self)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.setModel(self.listModel)
self.completer.activated.connect(self.Slot_completer_activated,
type=Qt.QueuedConnection)
# try:
# with open(self.qssFilePath, "r") as fh:
# self.completer.popup().setStyleSheet(fh.read())
# except Exception as e:
# logger.info('读取QSS文件失败' + str(e))
self.setCompleter(self.completer)
# 按下回车或单击后恢复显示模式 https://doc.qt.io/qt-5/qcompleter.html#activated
def Slot_completer_activated(self, text):
self.completer.setCompletionMode(QCompleter.PopupCompletion)
def event(self, event):
# 按下Tab键时弹出所有记录
if event.type() == QEvent.KeyPress:
if event.key() == Qt.Key_Tab:
# 设置不过滤显示 https://doc.qt.io/qt-5/qcompleter.html#completionMode-prop
if self.completer.completionCount() > 0:
self.completer.setCompletionMode(
QCompleter.UnfilteredPopupCompletion)
self.listModel.setStringList(self.inputList)
self.completer.complete()
self.completer.popup().show()
return True
elif event.key() == Qt.Key_Delete:
self.deleteEle(self.text())
return super().event(event)
def setEditable(self, state: bool):
if state:
super().setEditable(state)
qcom = QCompleter([str(r[0]) for r in self.FieldInfo.RowSource])
qcom.setCaseSensitivity(Qt.CaseInsensitive)
qcom.setCompletionMode(QCompleter.PopupCompletion)
qcom.setFilterMode(Qt.MatchContains)
self.setCompleter(qcom)
else:
super().setEditable(state)
def sku_completer(self):
# grab skus information from comapny.
root_skus = ip_data.get_sku_names()
# set up an auto complete for the sku line edit box
rsku_completer = QCompleter(root_skus)
rsku_completer.setCompletionMode(QCompleter.InlineCompletion)
rsku_completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
rsku_completer.setCaseSensitivity(Qt.CaseInsensitive)
self.le_search_sku.setCompleter(rsku_completer)
def __init__(self, *args, **kwargs):
super(DirLineEdit, self).__init__(*args, **kwargs)
completer = QCompleter()
completer.setCompletionMode(QCompleter.CompletionMode.PopupCompletion)
model = QFileSystemModel()
model.setRootPath('/')
model.setFilter(QDir.Filter.AllEntries | QDir.Filter.NoDotAndDotDot
| QDir.Filter.Hidden)
completer.setModel(model)
self.setCompleter(completer)
def __init__(self, qt_app: QApplication):
super().__init__()
self.qt_app = qt_app
self.setWindowTitle("PilleFightInterface")
self.setGeometry(10, 10, 300, 200)
self.SQLite = SqliteHandler()
outDict, userlist, valuelist, percentWin = util.outcomePerUser(self.SQLite.getCompleteList())
dbg(outDict)
dbg(valuelist)
dbg(userlist)
dbg(percentWin)
# @TODO: Evaluate if better done in a separate Module, inheriting QLineEdit
# @TODO: Spaghettifull
username = QLineEdit(USERNAME_PLACEHOLDER, self)
username.setFixedWidth(100)
username.move(0, 10)
username_completer = QCompleter(userlist, username)
username_completer.setCompletionMode(QCompleter.InlineCompletion)
username.setCompleter(username_completer)
fight_state = QLineEdit("won", self)
fight_state.setValidator(QFightStateValidator())
fight_state.setFixedWidth(100)
fight_state.setCompleter(QCompleter(["won", "lost"], fight_state))
fight_state.move(0,40)
insert_button = QPushButton("Register", self)
insert_button.setFixedWidth(80)
insert_button.move(0, 80)
insert_button.clicked.connect(lambda: self.on_submitToDatabaseClick(username.text(), fight_state.text()))
update_button = QPushButton("Update", self)
update_button.setFixedWidth(80)
update_button.move(80, 80)
update_button.clicked.connect(util.restart_program)
# @TODO: On the right side of the window i'd like to have a textbox read-only there to allow printing stats
# @TODO: Write a little statistical output module as well. Incorporate it onto the window title bar.
# @TODO: Follow-up statistical: Show an HTML output an a QWebView of said statistics.
self.app = qt_app
"""
self.Layout = QVBoxLayout()
self.Layout.addWidget(self.username)
self.Layout.addWidget(self.fight_state)
self.Layout.addWidget(insert_button)
self.setLayout(self.Layout)
"""
self.show()
self.statistics = StatisticsWindow(qt_app, userlist, valuelist)
def setCustomerCompleter(self):
nameToSearch = self.customerLineEdit.text()
compsearch = "SELECT NAME FROM customers WHERE NAME LIKE '" + nameToSearch + "%'"
completer = QCompleter()
self.customerCompModel = QSqlQueryModel()
self.customerCompModel.setQuery(compsearch)
completer.setModel(self.customerCompModel)
completer.setCompletionMode(completer.PopupCompletion)
completer.setCaseSensitivity(Qt.CaseInsensitive)
self.customerLineEdit.setCompleter(completer)
def init_style_config(self):
widget = QWidget()
layout = QFormLayout()
widget.setLayout(layout)
style_list = QComboBox()
complete = QCompleter(QStyleFactory.keys())
complete.setFilterMode(Qt.MatchContains)
complete.setCompletionMode(QCompleter.PopupCompletion)
style_list.setCompleter(complete)
style_list.setEditable(True)
style_list.addItems(QStyleFactory.keys())
layout.addRow('选择样式: ', style_list)
return widget
def updateTeamCompleters(self):
"""Refresh the completer for the team line edits."""
list = scctool.settings.config.getMyTeams() + \
["TBD"] + self.controller.historyManager.getTeamList()
for team_idx in range(2):
completer = QCompleter(list, self.le_team[team_idx])
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setCompletionMode(QCompleter.InlineCompletion)
completer.setFilterMode(Qt.MatchContains)
completer.setWrapAround(True)
completer.activated.connect(
self.le_team[team_idx].completerFinished)
self.le_team[team_idx].setCompleter(completer)
def setup_completer(self):
""" Sets up the autocomplete on the ancestor """
completer = QCompleter()
completer.setModel(self.model)
completer.setCompletionRole(Qt.DisplayRole)
completer.setCompletionColumn(self.text_column)
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setCompletionMode(QCompleter.PopupCompletion)
completer.setFilterMode(Qt.MatchContains)
# pylint: disable=unsubscriptable-object
signal = completer.activated[QModelIndex]
signal.connect(self.autocomplete_activated)
self.setCompleter(completer)
def createLayout(self):
layout = QFormLayout()
self.date = QDateEdit()
self.date.setDate(QDate.currentDate())
self.date.setCalendarPopup(True)
self.date.setFocusPolicy(Qt.StrongFocus)
layout.addRow("Data", self.date)
self.description = QLineEdit()
self.description.setMaxLength(40)
completer = QCompleter(DATABASE.getDescriptions())
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setCompletionMode(QCompleter.PopupCompletion)
self.description.setCompleter(completer)
layout.addRow("Descrição", self.description)
self.account1 = QComboBox()
self.account2 = QComboBox()
self.account1.setEditable(False)
self.account2.setEditable(False)
accounts = DATABASE.getAccounts()
for item in accounts:
self.account1.addItem(item)
self.account2.addItem(item)
self.account2.setCurrentIndex(1)
layout.addRow("De", self.account1)
layout.addRow("Para", self.account2)
self.value = QDoubleSpinBox()
self.value.setDecimals(2)
self.value.setPrefix("R$ ")
self.value.setSingleStep(100)
self.value.setRange(0, 1000000000)
layout.addRow("Valor", self.value)
sublayout = QHBoxLayout()
self.ok = QPushButton("Adicionar")
self.ok.clicked.connect(self.accept)
if not accounts:
self.ok.setEnabled(False)
cancel = QPushButton("Cancelar")
cancel.clicked.connect(self.reject)
sublayout.addWidget(self.ok)
sublayout.addWidget(cancel)
layout.addRow(sublayout)
self.setLayout(layout)
def initAccount(self):
# 自动填充账号密码
self._accounts = Setting.value('accounts', {}, QVariant)
completer = QCompleter(self._accounts.keys(), self.lineEditAccount)
completer.setCaseSensitivity(Qt.CaseInsensitive)
# 在内部自动填充完成
completer.setCompletionMode(QCompleter.InlineCompletion)
# 设置objectName用于设置样式
# completer.popup().setObjectName('lineEditAccountAuto')
self.lineEditAccount.setCompleter(completer)
# 读取储存的账号密码
account = Setting.value('account', '', str)
self.lineEditAccount.setText(account)
def __init__(self):
super(FTPWindow, self).__init__()
#setup UI from Qt Designer.
self.setupUi(self)
#setup a auto completer to choose campaign files from.
campaigns = self.get_campaigns()
camp_completer = QCompleter(campaigns)
camp_completer.setCompletionMode(QCompleter.InlineCompletion)
camp_completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
camp_completer.setCaseSensitivity(Qt.CaseInsensitive)
#we have to style this here instead of Qt Designer, because for some reason there is no way
#to style the popup using css.
camp_completer.popup().setStyleSheet("""selection-background-color: #ffaa00;
background-color: QLinearGradient( x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #565656, stop: 0.1 #525252, stop: 0.5 #4e4e4e, stop: 0.9 #4a4a4a, stop: 1 #464646);
border-style: solid;
border: 1px solid #1e1e1e;
border-radius: 5;""")
self.le_campaign.setCompleter(camp_completer)
#connect the button signals with the appropriate slots.
self.btn_dl_match.clicked.connect(self.btn_download_clicked)
#self.btn_match.clicked.connect(self.btn_match_clicked)
self.btn_dl_update.clicked.connect(self.btn_download_clicked)
self.btn_dl_cc.clicked.connect(self.btn_download_clicked)
### Start of new button set for listrak revamp ###
#opens file dialog to choose file
self.btn_match.clicked.connect(self.btn_match_clicked)
#starts the import into the database of the chosen file from above (btn_match)
self.btn_import.clicked.connect(self.btn_import_clicked)
#add Daves autoscale tool to the webview.
self.wv_autoscale.load(QUrl('http://inkpixi:4000/autoscale.php'))
self.actionExit.triggered.connect(qApp.instance().exit)
self.cb_garments.addItem('-- Select --')
garments = self.get_garments()
self.cb_garments.addItems(garments)
#self.cb_garments.currentIndexChanged.connect(self.get_top_fifty_start)
self.btn_top_fifty.clicked.connect(self.get_top_fifty_start)
now = datetime.now()
from_now = now - timedelta(days=90)
self.de_from.setDate(from_now)
self.de_to.setDate(now)
class FilteringComboBox(QComboBox):
"""Combination of QCombobox and QLineEdit with autocompletionself.
Line edit and completer model is taken from QSqlTable mod
Args:
table (str): db table name containing data for combobox
column (str): column name containing data for combobox
"""
def __init__(self, table, column, placeholderText, parent=None):
super(FilteringComboBox, self).__init__(parent)
self.parent = parent
self.setEditable(True)
self.setFocusPolicy(Qt.StrongFocus)
self.setInsertPolicy(QComboBox.NoInsert)
self.lineEdit().setPlaceholderText(placeholderText)
# setup data model
self._model = QSqlTableModel(self)
self._model.setTable(table)
self._model.select()
col_num = self._model.fieldIndex(column)
self._model.sort(col_num, Qt.AscendingOrder)
self.setModel(self._model)
self.setModelColumn(col_num)
# setup completer
self._proxy = QSortFilterProxyModel(self)
self._proxy.setFilterCaseSensitivity(Qt.CaseInsensitive)
self._proxy.setSourceModel(self._model)
self._proxy.setFilterKeyColumn(col_num)
self._completer = QCompleter(self)
self._completer.setModel(self._proxy)
self._completer.setCompletionColumn(col_num)
self._completer.activated.connect(self.onCompleterActivated)
self._completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.setCompleter(self._completer)
self.lineEdit().textEdited.connect(self._proxy.setFilterFixedString)
@pyqtSlot(str)
def onCompleterActivated(self, text):
if not text:
return
self.setCurrentIndex(self.findText(text))
self.activated[str].emit(self.currentText())
def updateModel(self):
self._model.select()
class ResearchFrame(QWidget, GuiComponent):
def __init__(self, parent):
super().__init__(parent)
self.gui = parent
self.gui.register_listener(self)
self.search = Research()
self.initFrame()
def initFrame(self):
self.createWidget()
self.show()
def refreshSearch(self, text):
if text is not "":
results = self.search.search(self.inputSearch.text().lower())
self.gui.dispatchAction("search-results", results)
self.model.setStringList([str(x) for x in results])
else:
self.gui.dispatchAction("show-initial-list")
def createWidget(self):
grid = QGridLayout(self)
self.lbl = QLabel("Please enter a resarch", self)
self.inputSearch = QLineEdit(self)
self.inputSearch.setFixedWidth(200)
self.completer = QCompleter()
self.completer.setCompletionMode(QCompleter.PopupCompletion)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.inputSearch.setCompleter(self.completer)
self.inputSearch.textChanged.connect(self.refreshSearch)
self.inputSearch.editingFinished.connect(self._showMovieList)
self.model = QStringListModel()
self.completer.setModel(self.model)
self.model.setStringList([])
self.btnOk = QPushButton("Launch the research", self)
grid.addWidget(self.lbl, 0, 0)
grid.addWidget(self.inputSearch, 0, 1)
grid.addWidget(self.btnOk, 0, 2)
self.setLayout(grid)
def _showMovieList(self, *args, **kwargs):
self.gui.dispatchAction("show-frame", "MovieList")
def handleAction(self, actionName, data):
pass
def requestAction(self, name):
pass
def set_completer(content, component):
""" 为控件添加自动补全
:param content: 候选内容
:param component: 控件
:return:
"""
# 增加自动补全
completer = QCompleter(content)
# 设置匹配模式，有三种： Qt.MatchStartsWith 开头匹配（默认） Qt.MatchContains 内容匹配 Qt.MatchEndsWith 结尾匹配
completer.setFilterMode(Qt.MatchContains)
# 设置补全模式，有三种： QCompleter.PopupCompletion（默认） QCompleter.InlineCompletion QCompleter.UnfilteredPopupCompletion
completer.setCompletionMode(QCompleter.PopupCompletion)
# 给控件设置补全器
component.setCompleter(completer)
class CompletingComboBox(QComboBox):
"""An editable combo box that filters and autocompletes."""
def __init__(self, parent=None):
super().__init__(parent)
self.setEditable(True)
self.filter = QSortFilterProxyModel(self)
self.filter.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.filter.setSourceModel(self.model())
self.completer = QCompleter(self.filter, self)
self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.setCompleter(self.completer)
self.lineEdit().textEdited.connect(
self.filter.setFilterFixedString)
self.currentIndexChanged.connect(self._index_changed)
def _index_changed(self, index):
self.lineEdit().selectAll()
def __init__(self, namespace, parent):
"""Constructor.
Args:
namespace: The local namespace of the interpreter.
"""
super().__init__(parent)
self.update_font()
objreg.get('config').changed.connect(self.update_font)
self.textChanged.connect(self.on_text_changed)
self._rlcompleter = rlcompleter.Completer(namespace)
qcompleter = QCompleter(self)
self._model = QStringListModel(qcompleter)
qcompleter.setModel(self._model)
qcompleter.setCompletionMode(
QCompleter.UnfilteredPopupCompletion)
qcompleter.setModelSorting(
QCompleter.CaseSensitivelySortedModel)
self.setCompleter(qcompleter)
self._history = cmdhistory.History()
self.returnPressed.connect(self.on_return_pressed)
class MainWindow(QMainWindow):
"""Main window class."""
def __init__(self, parent=None):
"""Init class."""
super(MainWindow, self).__init__()
QNetworkProxyFactory.setUseSystemConfiguration(True)
self.statusBar().showMessage(__doc__ + get_nuitka_version())
self.setWindowTitle(__doc__.strip().capitalize())
self.setMinimumSize(480, 400)
self.setMaximumSize(1024, 800)
self.resize(self.minimumSize())
self.setWindowIcon(QIcon.fromTheme("python"))
self.center()
QShortcut("Ctrl+q", self, activated=lambda: self.close())
self.menuBar().addMenu("&File").addAction("Exit", lambda: self.close())
windowMenu = self.menuBar().addMenu("&Window")
windowMenu.addAction("Minimize", lambda: self.showMinimized())
windowMenu.addAction("Maximize", lambda: self.showMaximized())
windowMenu.addAction("Restore", lambda: self.showNormal())
windowMenu.addAction("FullScreen", lambda: self.showFullScreen())
windowMenu.addAction("Center", lambda: self.center())
windowMenu.addAction("Top-Left", lambda: self.move(0, 0))
windowMenu.addAction("To Mouse", lambda: self.move_to_mouse_position())
windowMenu.addSeparator()
windowMenu.addAction(
"Increase size", lambda:
self.resize(self.size().width() * 1.4, self.size().height() * 1.4))
windowMenu.addAction("Decrease size", lambda: self.resize(
self.size().width() // 1.4, self.size().height() // 1.4))
windowMenu.addAction("Minimum size", lambda:
self.resize(self.minimumSize()))
windowMenu.addAction("Maximum size", lambda:
self.resize(self.maximumSize()))
windowMenu.addAction("Horizontal Wide", lambda: self.resize(
self.maximumSize().width(), self.minimumSize().height()))
windowMenu.addAction("Vertical Tall", lambda: self.resize(
self.minimumSize().width(), self.maximumSize().height()))
windowMenu.addSeparator()
windowMenu.addAction("Disable Resize", lambda:
self.setFixedSize(self.size()))
windowMenu.addAction("Set Interface Font...", lambda:
self.setFont(QFontDialog.getFont()[0]))
windowMenu.addAction(
"Load .qss Skin", lambda: self.setStyleSheet(self.skin()))
helpMenu = self.menuBar().addMenu("&Help")
helpMenu.addAction("About Qt 5", lambda: QMessageBox.aboutQt(self))
helpMenu.addAction("About Python 3",
lambda: open_new_tab('https://www.python.org'))
helpMenu.addAction("About " + __doc__,
lambda: QMessageBox.about(self, __doc__, HELP))
helpMenu.addSeparator()
helpMenu.addAction(
"Keyboard Shortcut",
lambda: QMessageBox.information(self, __doc__, "<b>Quit = CTRL+Q"))
if sys.platform.startswith('linux'):
helpMenu.addAction("View Source Code", lambda:
call('xdg-open ' + __file__, shell=True))
helpMenu.addAction("View GitHub Repo", lambda: open_new_tab(__url__))
helpMenu.addAction("Check Updates", lambda: Downloader(self))
# process
self.process = QProcess()
self.process.readyReadStandardOutput.connect(self._read_output)
self.process.readyReadStandardError.connect(self._read_errors)
self.process.finished.connect(self._process_finished)
self.process.error.connect(self._process_failed)
# widgets
self.group0, self.group1 = QGroupBox("Options"), QGroupBox("Paths")
self.group4, self.group5 = QGroupBox("Details"), QGroupBox("Miscs")
g0grid, g1vlay = QGridLayout(self.group0), QGridLayout(self.group1)
g5vlay, g4vlay = QVBoxLayout(self.group5), QVBoxLayout(self.group4)
# group 0 the options
self.module = QCheckBox("Create compiled extension module")
self.standalone = QCheckBox("Standalone executable binary output")
self.nofreeze = QCheckBox("No freeze all modules of standard library")
self.python_debug = QCheckBox("Use Python Debug")
self.warning = QCheckBox("Warnings for implicit exceptions at compile")
self.recurse_std = QCheckBox("Recursive compile the standard library")
self.recurse_not = QCheckBox("Force No recursive compiling")
self.execute = QCheckBox("Execute the created binary after compiling")
self.pythonpath = QCheckBox("Keep pythonpath when executing")
self.enhaced = QCheckBox("Enhaced compile, Not CPython compatible")
self.nolineno = QCheckBox("No Statements line numbers on compile")
self.rmbuilddir = QCheckBox("Remove build directory after compile.")
self.nuitka_debug = QCheckBox("Use Nuitka Debug")
self.keep_debug = QCheckBox("Keep debug info on compile for GDB")
self.traced = QCheckBox("Traced execution output")
self.plusplus = QCheckBox("Compile C++ Only on generated source files")
self.experimental = QCheckBox("Experimental features")
self.force_clang = QCheckBox("Force use of CLang")
self.force_mingw = QCheckBox("Force use of MinGW on MS Windows")
self.force_lto = QCheckBox("Use link time optimizations LTO")
self.show_scons = QCheckBox("Show Scons executed commands")
self.show_progress = QCheckBox("Show progress info and statistics")
self.show_summary = QCheckBox("Show final summary of included modules")
self.disable_console = QCheckBox("Disable the Console on MS Windows")
for i, widget in enumerate((
self.module, self.standalone, self.nofreeze, self.python_debug,
self.warning, self.recurse_std, self.recurse_not, self.execute,
self.pythonpath, self.enhaced, self.nolineno, self.rmbuilddir,
self.nuitka_debug, self.keep_debug, self.traced, self.plusplus,
self.experimental, self.force_clang, self.force_mingw,
self.force_lto, self.show_scons, self.show_progress,
self.show_summary, self.disable_console)):
widget.setToolTip(widget.text())
g0grid.addWidget(widget, i if i < i + 1 else i - (i - 1), i % 2)
# group 1 paths
self.target = QLineEdit()
self.outdir = QLineEdit(os.path.expanduser("~"))
self.t_icon = QLineEdit()
self.target.setToolTip("Python App file you want to Compile to Binary")
self.outdir.setToolTip("Folder to write Compiled Output Binary files")
self.t_icon.setToolTip("Icon image file to embed for your Python App")
self.target.setPlaceholderText("/full/path/to/target/python_app.py")
self.outdir.setPlaceholderText("/full/path/to/output/folder/")
self.t_icon.setPlaceholderText("/full/path/to/python_app/icon.png")
self.completer, self.dirs = QCompleter(self), QDirModel(self)
self.completer.setModel(self.dirs)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.setCompletionMode(QCompleter.PopupCompletion)
self.completer.popup().setStyleSheet("border: 1px solid gray")
self.completer.popup().setVerticalScrollBarPolicy(
Qt.ScrollBarAlwaysOff)
self.outdir.setCompleter(self.completer)
self.t_icon.setCompleter(self.completer)
self.target.setCompleter(self.completer)
self.clear_1 = QPushButton(QIcon.fromTheme("edit-clear"), "", self,
clicked=lambda: self.target.clear())
self.clear_2 = QPushButton(QIcon.fromTheme("edit-clear"), "", self,
clicked=lambda: self.t_icon.clear())
self.clear_3 = QPushButton(QIcon.fromTheme("edit-clear"), "", self,
clicked=lambda: self.outdir.clear())
self.open_1 = QPushButton(
QIcon.fromTheme("folder-open"), "", self, clicked=lambda:
self.target.setText(str(QFileDialog.getOpenFileName(
self, __doc__, os.path.expanduser("~"), """Python (*.py);;
Python for Windows (*.pyw);;All (*.*)""")[0])))
self.open_2 = QPushButton(
QIcon.fromTheme("folder-open"), "", self, clicked=lambda:
self.t_icon.setText(str(QFileDialog.getOpenFileName(
self, __doc__, os.path.expanduser("~"),
"PNG (*.png);;JPG (*.jpg);;ICO (*.ico);;All (*.*)")[0])))
self.open_3 = QPushButton(
QIcon.fromTheme("folder-open"), "", self, clicked=lambda:
self.outdir.setText(str(QFileDialog.getExistingDirectory(
self, __doc__, os.path.expanduser("~")))))
self.l_icon = QLabel("Target Icon")
g1vlay.addWidget(QLabel("<b>Target Python"), 0, 0)
g1vlay.addWidget(self.target, 0, 1)
g1vlay.addWidget(self.clear_1, 0, 2)
g1vlay.addWidget(self.open_1, 0, 3)
g1vlay.addWidget(self.l_icon, 1, 0)
g1vlay.addWidget(self.t_icon, 1, 1)
g1vlay.addWidget(self.clear_2, 1, 2)
g1vlay.addWidget(self.open_2, 1, 3)
g1vlay.addWidget(QLabel("<b>Output Folder"), 2, 0)
g1vlay.addWidget(self.outdir, 2, 1)
g1vlay.addWidget(self.clear_3, 2, 2)
g1vlay.addWidget(self.open_3, 2, 3)
# group 4 the dome view mode
self.jobs = QSpinBox()
self.jobs.setRange(1, cpu_count())
self.jobs.setValue(cpu_count())
self.jobs.setToolTip("Backend Worker Jobs Processes")
self.python_version = QComboBox()
self.python_version.addItems(["2.7", "3.2", "3.3", "3.4"])
self.python_version.setToolTip("Python version to use with Nuitka")
self.display_tree = QPushButton("Display Tree")
self.display_tree.clicked.connect(
lambda: call(NUITKA + " --display-tree {}".format(
self.target.text()), shell=True))
self.dump_tree = QPushButton(
"View Docs", clicked=lambda:
open_new_tab("http://nuitka.net/doc/user-manual.html"))
self.open_log = QPushButton("View Logs")
_log = os.path.join(gettempdir(), "nuitka-gui.log")
_open = "xdg-open " if sys.platform.startswith("lin") else "open "
self.open_log.clicked.connect(lambda: call(_open + _log, shell=True))
self.open_folder = QPushButton("Open Build Folder")
self.open_folder.clicked.connect(lambda: call(
_open + str(self.outdir.text()).strip(), shell=True))
# self.display_tree.clicked.connect(self._display_tree)
g4vlay.addWidget(QLabel("<b>Worker Jobs"))
g4vlay.addWidget(self.jobs)
g4vlay.addWidget(QLabel("<b>Python Version"))
g4vlay.addWidget(self.python_version)
g4vlay.addWidget(QLabel("<b>Actions"))
g4vlay.addWidget(self.display_tree)
g4vlay.addWidget(self.dump_tree)
g4vlay.addWidget(self.open_log)
g4vlay.addWidget(self.open_folder)
# group 5 miscelaneous stuff
self.debug, self.scr = QCheckBox("Use Debug"), QCheckBox("Make Script")
self.chrt, self.ionice = QCheckBox("Slow CPU"), QCheckBox("Slow HDD")
self.minimi = QCheckBox("Auto Minimize")
self.chrt.setToolTip("Use Low CPU speed priority (Linux only)")
self.ionice.setToolTip("Use Low HDD speed priority (Linux only)")
self.scr.setToolTip("Generate a Bash Script to Compile with Nuitka")
self.debug.setToolTip("Use Debug Verbose mode")
self.minimi.setToolTip("Automatically Minimize when compiling starts")
self.scr.setChecked(True)
self.chrt.setChecked(True)
self.ionice.setChecked(True)
self.minimi.setChecked(True)
g5vlay.addWidget(self.debug)
g5vlay.addWidget(self.scr)
g5vlay.addWidget(self.chrt)
g5vlay.addWidget(self.ionice)
g5vlay.addWidget(self.minimi)
# option to show or hide some widgets on the gui
self.guimode = QComboBox()
self.guimode.addItems(('Full UX / UI', 'Simple UX / UI'))
self.guimode.setCurrentIndex(1)
self._set_guimode()
self.guimode.setStyleSheet("""QComboBox{background:transparent;
margin-left:25px;color:gray;text-decoration:underline;border:0}""")
self.guimode.currentIndexChanged.connect(self._set_guimode)
# buttons from bottom to close or proceed
self.bt = QDialogButtonBox(self)
self.bt.setStandardButtons(
QDialogButtonBox.Ok | QDialogButtonBox.Close)
self.bt.rejected.connect(self.close)
self.bt.accepted.connect(self.run)
if not sys.platform.startswith('lin'):
self.scr.setChecked(False)
self.chrt.setChecked(False)
self.ionice.setChecked(False)
self.scr.hide()
self.chrt.hide()
self.ionice.hide()
if not sys.platform.startswith('win'):
self.l_icon.hide()
self.t_icon.hide()
self.clear_2.hide()
self.open_2.hide()
if sys.platform.startswith('win'):
self.display_tree.hide()
# container for all groups of widgets
container = QWidget()
container_layout = QGridLayout(container) # Y, X
container_layout.addWidget(self.guimode, 0, 1)
container_layout.addWidget(self.group0, 1, 1)
container_layout.addWidget(self.group1, 2, 1)
container_layout.addWidget(self.group4, 1, 2)
container_layout.addWidget(self.group5, 2, 2)
container_layout.addWidget(self.bt, 3, 1)
self.setCentralWidget(container)
def check_paths(self):
"""Check that the paths are valid."""
if not os.path.isfile(self.target.text()):
log.error("Target File not found or not valid.")
QMessageBox.warning(self, __doc__.title(),
"Target File not found or not valid.")
return False
if not str(self.target.text()).endswith((".py", ".pyw")):
log.error("Target File not valid.")
QMessageBox.warning(self, __doc__.title(),
"Target File not valid.")
return False
if not os.path.isdir(self.outdir.text()):
log.error("Target Folder not found or not valid.")
QMessageBox.warning(self, __doc__.title(),
"Target Folder not found or not valid.")
return False
if self.t_icon.text() and not os.path.isfile(self.t_icon.text()):
log.warning("Target Icon File not found or not valid.")
QMessageBox.warning(self, __doc__.title(),
"Target Icon File not found or not valid.")
return True
else:
return True
def generate_build_command(self):
"""Generate a build command."""
return re.sub(r"\s+", " ", " ".join((
'chrt --verbose --idle 0' if self.chrt.isChecked() else '',
'ionice --ignore --class 3' if self.ionice.isChecked() else '',
NUITKA,
'--debug --verbose' if self.debug.isChecked() else '',
'--show-progress' if self.show_progress.isChecked() else '',
'--show-scons --show-modules' if self.show_scons.isChecked() else '',
'--unstriped' if self.keep_debug.isChecked() else '',
'--trace-execution' if self.traced.isChecked() else '',
'--remove-output' if self.rmbuilddir.isChecked() else '',
'--code-gen-no-statement-lines' if self.nolineno.isChecked() else '',
'--execute' if self.execute.isChecked() else '',
'--recurse-none' if self.recurse_not.isChecked() else '--recurse-all',
'--recurse-stdlib' if self.recurse_std.isChecked() else '',
'--clang' if self.force_clang.isChecked() else '',
'--lto' if self.force_lto.isChecked() else '',
'--c++-only' if self.plusplus.isChecked() else '',
'--windows-disable-console' if self.disable_console.isChecked() else '',
'--experimental' if self.experimental.isChecked() else '',
'--python-debug' if self.python_debug.isChecked() else '',
'--module' if self.module.isChecked() else '--standalone',
'--nofreeze-stdlib' if self.nofreeze.isChecked() else '',
'--mingw' if self.force_mingw.isChecked() else '',
'--warn-implicit-exceptions' if self.warning.isChecked() else '',
'--execute-with-pythonpath' if self.pythonpath.isChecked() else '',
'--enhanced' if self.enhaced.isChecked() else '',
'--icon="{}"'.format(self.t_icon.text()) if self.t_icon.text() else '',
'--python-version={}'.format(self.python_version.currentText()),
'--jobs={}'.format(self.jobs.value()),
'--output-dir="{}"'.format(self.outdir.text()),
'"{}"'.format(self.target.text()))))
def run(self):
"""Run the main method and run Nuitka."""
self.statusBar().showMessage('Working...')
log.debug("Working...")
if not self.check_paths():
return
command_to_run_nuitka = self.generate_build_command()
log.debug(command_to_run_nuitka)
self.process.start(command_to_run_nuitka)
if not self.process.waitForStarted():
log.error(self._read_errors())
return # ERROR
if self.scr.isChecked() and sys.platform.startswith("lin"):
script_file = str(self.target.text()).replace(".py",
"-nuitka-compile.sh")
log.debug("Writing Script {}".format(script_file))
with open(script_file, "w", encoding="utf-8") as script:
script.write("#!/usr/bin/env bash\n" + command_to_run_nuitka)
os.chmod(script_file, 0o755)
self.statusBar().showMessage(__doc__.title())
def _process_finished(self):
"""Finished sucessfuly."""
log.debug("Finished.")
self.showNormal()
def _read_output(self):
"""Read and return output."""
return str(self.process.readAllStandardOutput()).strip()
def _read_errors(self):
"""Read and return errors."""
log.debug(self.process.readAllStandardError())
return str(self.process.readAllStandardError()).strip()
def _process_failed(self):
"""Read and return errors."""
self.showNormal()
self.statusBar().showMessage(" ERROR: Failed ! ")
log.warning(str(self.process.readAllStandardError()).strip().lower())
return str(self.process.readAllStandardError()).strip().lower()
def _set_guimode(self):
"""Switch between simple and full UX."""
for widget in (self.group0, self.group4,
self.group5, self.statusBar(), self.menuBar()):
widget.hide() if self.guimode.currentIndex() else widget.show()
self.resize(self.minimumSize()
if self.guimode.currentIndex() else self.maximumSize())
self.center()
def skin(self, filename=None):
"""Open QSS from filename,if no QSS return None,if no filename ask."""
if not filename:
filename = str(QFileDialog.getOpenFileName(
self, __doc__ + "-Open QSS Skin file", os.path.expanduser("~"),
"CSS Cascading Style Sheet for Qt 5 (*.qss);;All (*.*)")[0])
if filename and os.path.isfile(filename):
log.debug(filename)
with open(filename, 'r') as file_to_read:
text = file_to_read.read().strip()
if text:
log.debug(text)
return text
def center(self):
"""Center the Window on the Current Screen,with Multi-Monitor support.
>>> MainWindow().center()
True
"""
window_geometry = self.frameGeometry()
mousepointer_position = QApplication.desktop().cursor().pos()
screen = QApplication.desktop().screenNumber(mousepointer_position)
centerPoint = QApplication.desktop().screenGeometry(screen).center()
window_geometry.moveCenter(centerPoint)
return bool(not self.move(window_geometry.topLeft()))
def move_to_mouse_position(self):
"""Center the Window on the Current Mouse position.
>>> MainWindow().move_to_mouse_position()
True
"""
window_geometry = self.frameGeometry()
window_geometry.moveCenter(QApplication.desktop().cursor().pos())
return bool(not self.move(window_geometry.topLeft()))
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 init_toolbar(self):
self.toolbar = QToolBar()
self.toolbar.setFixedHeight(25)
self.toolbar.setWindowTitle("Show") # text for the contextmenu
#self.toolbar.setStyleSheet("QToolBar {border:0px}") # make it user defined?
self.toolbar.setMovable(False)
self.toolbar.setFloatable(False)
#self.toolbar.setIconSize(QSize(20,20))
self.toolbar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
self.toolbar.setIconSize(QSize(20,20))
spacer_start = QWidget() # aligns the first actions properly
spacer_start.setFixedSize(QSize(10, 1))
self.toolbar.addWidget(spacer_start)
self.favourite_btn = misc.ToolbarButton(self.toolbar, 'Favorites')
self.toolbar.addWidget(self.favourite_btn)
self.favourite_btn.clicked.connect(self.favourite_display) #need lambda to pass extra args
self.library_btn = misc.ToolbarButton(self.toolbar, 'Library')
self.toolbar.addWidget(self.library_btn)
self.library_btn.clicked.connect(self.catalog_display) #need lambda to pass extra args
self.library_btn.selected = True
self.toolbar.addSeparator()
gallery_menu = QMenu()
gallery_action = QToolButton()
gallery_action.setText('Gallery ')
gallery_action.setPopupMode(QToolButton.InstantPopup)
gallery_action.setToolTip('Contains various gallery related features')
gallery_action.setMenu(gallery_menu)
add_gallery_icon = QIcon(app_constants.PLUS_PATH)
gallery_action_add = QAction(add_gallery_icon, "Add single gallery...", self)
gallery_action_add.triggered.connect(self.manga_list_view.SERIES_DIALOG.emit)
gallery_action_add.setToolTip('Add a single gallery thoroughly')
gallery_menu.addAction(gallery_action_add)
add_more_action = QAction(add_gallery_icon, "Add galleries...", self)
add_more_action.setStatusTip('Add galleries from different folders')
add_more_action.triggered.connect(lambda: self.populate(True))
gallery_menu.addAction(add_more_action)
populate_action = QAction(add_gallery_icon, "Populate from directory/archive...", self)
populate_action.setStatusTip('Populates the DB with galleries from a single folder or archive')
populate_action.triggered.connect(self.populate)
gallery_menu.addAction(populate_action)
gallery_menu.addSeparator()
metadata_action = QAction('Get metadata for all galleries', self)
metadata_action.triggered.connect(self.get_metadata)
gallery_menu.addAction(metadata_action)
scan_galleries_action = QAction('Scan for new galleries', self)
scan_galleries_action.triggered.connect(self.scan_for_new_galleries)
scan_galleries_action.setStatusTip('Scan monitored folders for new galleries')
gallery_menu.addAction(scan_galleries_action)
gallery_action_random = gallery_menu.addAction("Open random gallery")
gallery_action_random.triggered.connect(self.manga_list_view.open_random_gallery)
self.toolbar.addWidget(gallery_action)
misc_action = QToolButton()
misc_action.setText('Tools ')
misc_action_menu = QMenu()
misc_action.setMenu(misc_action_menu)
misc_action.setPopupMode(QToolButton.InstantPopup)
misc_action.setToolTip("Contains misc. features")
gallery_downloader = QAction("Gallery Downloader", misc_action_menu)
gallery_downloader.triggered.connect(self.download_window.show)
misc_action_menu.addAction(gallery_downloader)
duplicate_check_simple = QAction("Simple Duplicate Finder", misc_action_menu)
duplicate_check_simple.triggered.connect(lambda: self.manga_list_view.duplicate_check())
misc_action_menu.addAction(duplicate_check_simple)
self.toolbar.addWidget(misc_action)
spacer_middle = QWidget() # aligns buttons to the right
spacer_middle.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.toolbar.addWidget(spacer_middle)
sort_action = QToolButton()
sort_action.setIcon(QIcon(app_constants.SORT_PATH))
sort_action.setMenu(misc.SortMenu(self.toolbar, self.manga_list_view))
sort_action.setPopupMode(QToolButton.InstantPopup)
self.toolbar.addWidget(sort_action)
self.grid_toggle_g_icon = QIcon(app_constants.GRID_PATH)
self.grid_toggle_l_icon = QIcon(app_constants.LIST_PATH)
self.grid_toggle = QToolButton()
if self.display.currentIndex() == self.m_l_view_index:
self.grid_toggle.setIcon(self.grid_toggle_l_icon)
else:
self.grid_toggle.setIcon(self.grid_toggle_g_icon)
self.grid_toggle.setObjectName('gridtoggle')
self.grid_toggle.clicked.connect(self.toggle_view)
self.toolbar.addWidget(self.grid_toggle)
spacer_mid2 = QWidget()
spacer_mid2.setFixedSize(QSize(5, 1))
self.toolbar.addWidget(spacer_mid2)
def set_search_case(b):
app_constants.GALLERY_SEARCH_CASE = b
settings.set(b, 'Application', 'gallery search case')
settings.save()
def set_search_strict(b):
app_constants.GALLERY_SEARCH_STRICT = b
settings.set(b, 'Application', 'gallery search strict')
settings.save()
self.search_bar = misc.LineEdit()
search_options = self.search_bar.addAction(QIcon(app_constants.SEARCH_OPTIONS_PATH), QLineEdit.TrailingPosition)
search_options_menu = QMenu(self)
search_options.triggered.connect(lambda: search_options_menu.popup(QCursor.pos()))
search_options.setMenu(search_options_menu)
case_search_option = search_options_menu.addAction('Case Sensitive')
case_search_option.setCheckable(True)
case_search_option.setChecked(app_constants.GALLERY_SEARCH_CASE)
case_search_option.toggled.connect(set_search_case)
strict_search_option = search_options_menu.addAction('Match whole terms')
strict_search_option.setCheckable(True)
strict_search_option.setChecked(app_constants.GALLERY_SEARCH_STRICT)
strict_search_option.toggled.connect(set_search_strict)
self.search_bar.setObjectName('search_bar')
self.search_timer = QTimer(self)
self.search_timer.setSingleShot(True)
self.search_timer.timeout.connect(lambda: self.search(self.search_bar.text()))
self._search_cursor_pos = [0, 0]
def set_cursor_pos(old, new):
self._search_cursor_pos[0] = old
self._search_cursor_pos[1] = new
self.search_bar.cursorPositionChanged.connect(set_cursor_pos)
if app_constants.SEARCH_AUTOCOMPLETE:
completer = QCompleter(self)
completer_view = misc.CompleterPopupView()
completer.setPopup(completer_view)
completer_view._setup()
completer.setModel(self.manga_list_view.gallery_model)
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setCompletionMode(QCompleter.PopupCompletion)
completer.setCompletionRole(Qt.DisplayRole)
completer.setCompletionColumn(app_constants.TITLE)
completer.setFilterMode(Qt.MatchContains)
self.search_bar.setCompleter(completer)
self.search_bar.returnPressed.connect(lambda: self.search(self.search_bar.text()))
if not app_constants.SEARCH_ON_ENTER:
self.search_bar.textEdited.connect(lambda: self.search_timer.start(800))
self.search_bar.setPlaceholderText("Search title, artist, namespace & tags")
self.search_bar.setMinimumWidth(150)
self.search_bar.setMaximumWidth(500)
self.search_bar.setFixedHeight(19)
self.manga_list_view.sort_model.HISTORY_SEARCH_TERM.connect(lambda a: self.search_bar.setText(a))
self.toolbar.addWidget(self.search_bar)
def search_history(_, back=True): # clicked signal passes a bool
sort_model = self.manga_list_view.sort_model
nav = sort_model.PREV if back else sort_model.NEXT
history_term = sort_model.navigate_history(nav)
if back:
self.search_forward.setVisible(True)
back = QShortcut(QKeySequence(QKeySequence.Back), self, lambda: search_history(None))
forward = QShortcut(QKeySequence(QKeySequence.Forward), self, lambda: search_history(None, False))
search_backbutton = QToolButton(self.toolbar)
search_backbutton.setText(u'\u25C0')
search_backbutton.setFixedWidth(15)
search_backbutton.clicked.connect(search_history)
self.search_backward = self.toolbar.addWidget(search_backbutton)
self.search_backward.setVisible(False)
search_forwardbutton = QToolButton(self.toolbar)
search_forwardbutton.setText(u'\u25B6')
search_forwardbutton.setFixedWidth(15)
search_forwardbutton.clicked.connect(lambda: search_history(None, False))
self.search_forward = self.toolbar.addWidget(search_forwardbutton)
self.search_forward.setVisible(False)
spacer_end = QWidget() # aligns settings action properly
spacer_end.setFixedSize(QSize(10, 1))
self.toolbar.addWidget(spacer_end)
settings_act = QToolButton(self.toolbar)
settings_act.setIcon(QIcon(app_constants.SETTINGS_PATH))
settings_act.clicked.connect(self.settings)
self.toolbar.addWidget(settings_act)
spacer_end2 = QWidget() # aligns About action properly
spacer_end2.setFixedSize(QSize(5, 1))
self.toolbar.addWidget(spacer_end2)
self.addToolBar(self.toolbar)
def init_toolbar(self):
self.toolbar = QToolBar()
self.toolbar.setFixedHeight(25)
self.toolbar.setWindowTitle("Show") # text for the contextmenu
# self.toolbar.setStyleSheet("QToolBar {border:0px}") # make it user defined?
self.toolbar.setMovable(False)
self.toolbar.setFloatable(False)
# self.toolbar.setIconSize(QSize(20,20))
self.toolbar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
spacer_start = QWidget() # aligns the first actions properly
spacer_start.setFixedSize(QSize(10, 1))
self.toolbar.addWidget(spacer_start)
favourite_view_icon = QIcon(gui_constants.STAR_BTN_PATH)
favourite_view_action = QAction(favourite_view_icon, "Favorites", self)
favourite_view_action.setToolTip("Show only favourite galleries")
favourite_view_action.triggered.connect(self.favourite_display) # need lambda to pass extra args
self.toolbar.addAction(favourite_view_action)
catalog_view_icon = QIcon(gui_constants.HOME_BTN_PATH)
catalog_view_action = QAction(catalog_view_icon, "Library", self)
catalog_view_action.setToolTip("Show all your galleries")
# catalog_view_action.setText("Catalog")
catalog_view_action.triggered.connect(self.catalog_display) # need lambda to pass extra args
self.toolbar.addAction(catalog_view_action)
self.toolbar.addSeparator()
gallery_menu = QMenu()
gallery_action = QToolButton()
gallery_action.setText("Gallery ")
gallery_action.setPopupMode(QToolButton.InstantPopup)
gallery_action.setToolTip("Contains various gallery related features")
gallery_action.setMenu(gallery_menu)
add_gallery_icon = QIcon(gui_constants.PLUS_PATH)
gallery_action_add = QAction(add_gallery_icon, "Add gallery", self)
gallery_action_add.triggered.connect(self.manga_list_view.SERIES_DIALOG.emit)
gallery_action_add.setToolTip("Add a single gallery thoroughly")
gallery_menu.addAction(gallery_action_add)
add_more_action = QAction(add_gallery_icon, "Add galleries...", self)
add_more_action.setStatusTip("Add galleries from different folders")
add_more_action.triggered.connect(lambda: self.populate(True))
gallery_menu.addAction(add_more_action)
populate_action = QAction(add_gallery_icon, "Populate from folder...", self)
populate_action.setStatusTip("Populates the DB with galleries from a single folder")
populate_action.triggered.connect(self.populate)
gallery_menu.addAction(populate_action)
gallery_menu.addSeparator()
metadata_action = QAction("Get metadata for all galleries", self)
metadata_action.triggered.connect(self.get_metadata)
gallery_menu.addAction(metadata_action)
self.toolbar.addWidget(gallery_action)
self.toolbar.addSeparator()
misc_action = QToolButton()
misc_action.setText("Misc ")
misc_action_menu = QMenu()
misc_action.setMenu(misc_action_menu)
misc_action.setPopupMode(QToolButton.InstantPopup)
misc_action.setToolTip("Contains misc. features")
misc_action_random = QAction("Open random gallery", misc_action_menu)
misc_action_random.triggered.connect(self.manga_list_view.open_random_gallery)
misc_action_menu.addAction(misc_action_random)
duplicate_check_simple = QAction("Simple duplicate finder", misc_action_menu)
duplicate_check_simple.triggered.connect(lambda: self.manga_list_view.duplicate_check())
misc_action_menu.addAction(duplicate_check_simple)
self.toolbar.addWidget(misc_action)
spacer_middle = QWidget() # aligns buttons to the right
spacer_middle.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.toolbar.addWidget(spacer_middle)
self.grid_toggle_g_icon = QIcon(gui_constants.GRID_PATH)
self.grid_toggle_l_icon = QIcon(gui_constants.LIST_PATH)
self.grid_toggle = QToolButton()
if self.display.currentIndex() == self.m_l_view_index:
self.grid_toggle.setIcon(self.grid_toggle_l_icon)
else:
self.grid_toggle.setIcon(self.grid_toggle_g_icon)
self.grid_toggle.setObjectName("gridtoggle")
self.grid_toggle.clicked.connect(self.toggle_view)
self.toolbar.addWidget(self.grid_toggle)
self.search_bar = misc.LineEdit()
if gui_constants.SEARCH_AUTOCOMPLETE:
completer = QCompleter(self)
completer.setModel(self.manga_list_view.gallery_model)
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setCompletionMode(QCompleter.PopupCompletion)
completer.setCompletionRole(Qt.DisplayRole)
completer.setCompletionColumn(gui_constants.TITLE)
completer.setFilterMode(Qt.MatchContains)
self.search_bar.setCompleter(completer)
if gui_constants.SEARCH_ON_ENTER:
self.search_bar.returnPressed.connect(lambda: self.search(self.search_bar.text()))
else:
self.search_bar.textChanged[str].connect(self.search)
self.search_bar.setPlaceholderText("Search title, artist, namespace & tags")
self.search_bar.setMinimumWidth(150)
self.search_bar.setMaximumWidth(500)
self.toolbar.addWidget(self.search_bar)
self.toolbar.addSeparator()
settings_icon = QIcon(gui_constants.SETTINGS_PATH)
settings_action = QAction("Set&tings", self)
settings_action.triggered.connect(self.settings)
self.toolbar.addAction(settings_action)
spacer_end = QWidget() # aligns About action properly
spacer_end.setFixedSize(QSize(10, 1))
self.toolbar.addWidget(spacer_end)
self.addToolBar(self.toolbar)
class ZoomToPostcode:
"""QGIS Plugin Implementation."""
METADATA_URL = "http://qgis.locationcentre.co.uk/ZoomToPostcode_medata.xml"
POSTCODE_URL = "http://qgis.locationcentre.co.uk/UK_Postcodes.zip"
def __init__(self, iface):
"""Constructor.
:param iface: An interface instance that will be passed to this class
which provides the hook by which you can manipulate the QGIS
application at run time.
:type iface: QgsInterface
"""
# Save reference to the QGIS interface
self.iface = iface
self.canvas = iface.mapCanvas()
# initialize plugin directory
self.plugin_dir = path.dirname(__file__)
# initialize locale
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = path.join(
self.plugin_dir,
'i18n',
'ZoomToPostcode_{}.qm'.format(locale))
if path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
# Create the dialog (after translation) and keep reference
self.dlg = ZoomToPostcodeDialog()
# Create licence dlg
self.licence_dlg = LicenceDialog()
# Create various class references
self.marker = None
self.completer = None
self.previous_searches = []
# Declare instance attributes
self.actions = []
self.menu = self.tr(u'&Zoom To Postcode')
self.toolbar = self.iface.addToolBar(u'ZoomToPostcode')
self.toolbar.setObjectName(u'ZoomToPostcode')
# noinspection PyMethodMayBeStatic
def tr(self, message):
"""Get the translation for a string using Qt translation API.
We implement this ourselves since we do not inherit QObject.
:param message: String for translation.
:type message: str, QString
:returns: Translated version of message.
:rtype: QString
"""
# noinspection PyTypeChecker,PyArgumentList,PyCallByClass
return QCoreApplication.translate('ZoomToPostcode', message)
def add_action(
self,
icon_path,
text,
callback,
enabled_flag=True,
add_to_menu=True,
add_to_toolbar=True,
status_tip=None,
whats_this=None,
parent=None):
"""Add a toolbar icon to the toolbar."""
icon = QIcon(icon_path)
action = QAction(icon, text, parent)
action.triggered.connect(callback)
action.setEnabled(enabled_flag)
if status_tip is not None:
action.setStatusTip(status_tip)
if whats_this is not None:
action.setWhatsThis(whats_this)
if add_to_toolbar:
self.toolbar.addAction(action)
if add_to_menu:
self.iface.addPluginToMenu(
self.menu,
action)
self.actions.append(action)
return action
def initGui(self):
"""Create the menu entries and toolbar icons inside the QGIS GUI."""
icon_path = ':/plugins/zoom_to_postcode/icon.png'
self.add_action(
icon_path,
text=self.tr(u'Zoom to postcode'),
callback=self.run,
parent=self.iface.mainWindow())
# Configure toolbar widget
self.toolbar = self.iface.addToolBar("Zoom To Postcode Toolbar")
self.toolbar.setObjectName("Zoom To Postcode Toolbar")
self.toolbar_search = QLineEdit()
self.toolbar_search.setMaximumWidth(100)
self.toolbar_search.setAlignment(Qt.AlignLeft)
self.toolbar_search.setPlaceholderText("Enter postcode...")
self.toolbar.addWidget(self.toolbar_search)
self.toolbar_search.returnPressed.connect(self.check_pkl)
self.search_btn = QAction(QIcon(":/plugins/zoomtopostcode/zoomicon.png"), "Search", self.iface.mainWindow())
self.search_btn.triggered.connect(self.check_pkl)
self.toolbar.addActions([self.search_btn])
# Create action that will start plugin configuration
self.action = QAction(QIcon(":/plugins/zoomtopostcode/zoomicon.png"), u"Zoom to Postcode",
self.iface.mainWindow())
self.action.triggered.connect(self.toolbar.show)
self.licence = QAction(u"OS Licence", self.iface.mainWindow())
self.licence.triggered.connect(self.licence_dlg.show)
# Add toolbar button and menu item
self.iface.addPluginToMenu(u"&Zoom to Postcode", self.action)
self.iface.addPluginToMenu(u"&Zoom to Postcode", self.licence)
def unload(self):
"""Removes the plugin menu item and icon from QGIS GUI."""
for action in self.actions:
self.iface.removePluginMenu(
self.tr(u'&Zoom To Postcode'),
action)
self.iface.removeToolBarIcon(action)
# remove the toolbar
del self.toolbar
def run(self):
"""Show the toolbar dialog."""
self.dlg.show()
def search_completer(self):
self.completer = QCompleter(self.previous_searches, self.iface.mainWindow())
self.completer.setCompletionMode(QCompleter.PopupCompletion)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
def check_crs(self):
"""Check if a transformation needs to take place.
:return: None
"""
srs = self.canvas.mapSettings().destinationCrs()
current_crs = srs.authid()
return current_crs
def transform(self, cor):
"""Transforms point from british nation grid to map crs.
:param cor: Coords
:return: Point
"""
srs = self.canvas.mapSettings().destinationCrs()
crs_src = QgsCoordinateReferenceSystem(27700)
crs_dest = QgsCoordinateReferenceSystem(srs)
xform = QgsCoordinateTransform(crs_src, crs_dest, QgsProject.instance())
x, y = cor
t_point = xform.transform(float(x), float(y))
return t_point
def check_pkl(self):
"""Check the Pickle postcode dir exists.
:return: None
"""
checkpkl = path.isdir(path.join(self.plugin_dir, 'UK_Postcodes'))
if checkpkl:
xml_path = path.join(self.plugin_dir, r'UK_Postcodes/metadata.xml')
check_xml = path.isfile(xml_path)
if check_xml:
check_currency = self.check_pcode_date(xml_path)
if check_currency:
self.postcode_dict()
else:
self.update_pcode_option()
else:
self.update_pcode_option()
else:
msg = "Postcode files must be downloaded to use this plugin, do you wish to continue?"
goahead = QMessageBox.question(self.iface.mainWindow(), "Download Message", msg, QMessageBox.Yes,
QMessageBox.No)
if goahead == QMessageBox.Yes:
self.download_pkl()
else:
pass
def check_pcode_date(self, xml_path):
"""Parses metadata xml to check currency of pcodes.
:param xml_path: Full path to xml file.
:return: True for up-to-date postcodes, False requires download to update
"""
try:
http = urllib3.PoolManager()
r = http.request('GET', self.METADATA_URL, retries=3)
xml_as_string = ET.fromstring(r.data.decode('utf-8'))
tree_web = ET.ElementTree(xml_as_string)
root_web = tree_web.getroot()
current_version = ""
for child in root_web:
if child.tag == "pcode_date":
current_version = child.text
tree_plugin = ET.parse(xml_path)
root_plugin = tree_plugin.getroot()
last_update = ""
for child in root_plugin:
if child.tag == "pcode_date":
last_update = child.text
last_up_datetime = datetime.strptime(last_update, '%Y-%m-%d')
curr_ver_datetime = datetime.strptime(current_version, '%Y-%m-%d')
if last_up_datetime.date() >= curr_ver_datetime.date():
return True
else:
return False
except urllib3.exceptions.MaxRetryError:
QMessageBox.information(self.iface.mainWindow(),
"HTTP Error",
"Unable to download file")
def update_pcode_option(self):
"""Provide option to update postcodes.
:return: None
"""
msg = "Updated postcode files are available, do you wish to download?"
goahead = QMessageBox.question(self.iface.mainWindow(), "Download Message", msg, QMessageBox.Yes,
QMessageBox.No)
if goahead == QMessageBox.Yes:
self.download_pkl()
if goahead == QMessageBox.No:
self.postcode_dict()
def download_pkl(self):
"""Download the Pickle postcode file to the plugin dir.
:return: None
"""
pcode_path = path.join(path.dirname(__file__), 'UK_Postcodes')
if not path.exists(pcode_path):
makedirs(pcode_path)
try:
http = urllib3.PoolManager()
response = http.request('GET', self.POSTCODE_URL, preload_content=False, retries=3)
content_length = response.headers['Content-Length']
total_size = int(content_length)
downloaded = 0
CHUNK = 256 * 10240
dlbar = QProgressBar()
dlbar.setMinimum(0)
dlbar.setMaximum(total_size)
zip_temp = tempfile.NamedTemporaryFile(mode='w+b', suffix='.zip', delete=False)
zip_temp_n = zip_temp.name
zip_temp.seek(0)
with open(zip_temp_n, 'wb') as fp:
while True:
dlbar.show()
chunk = response.read(CHUNK)
downloaded += len(chunk)
dlbar.setValue(downloaded)
if not chunk:
break
fp.write(chunk)
response.release_conn()
pcode_zip = ZipFile(zip_temp)
pcode_zip.extractall(pcode_path)
zip_temp.close()
self.check_pkl()
except urllib3.exceptions.MaxRetryError:
QMessageBox.information(self.iface.mainWindow(),
"HTTP Error",
"Unable to download file")
def postcode_dict(self):
"""Create dictionary of postcodes from correct Pickle file.
:return: None
"""
try:
input_pcode = self.toolbar_search.text().replace(' ', '')
if input_pcode[1].isdigit():
find_pkl = str(r"UK_Postcodes/" + input_pcode[:1] + ".pkl")
else:
find_pkl = str(r"UK_Postcodes/" + input_pcode[:2] + ".pkl")
pklfile = open(path.join(path.dirname(__file__), find_pkl), 'rb')
pcode_dict = pickle.load(pklfile)
pklfile.close()
if input_pcode.upper() not in self.previous_searches:
self.previous_searches.append(input_pcode.upper())
self.search_completer()
self.toolbar_search.setCompleter(self.completer)
self.zoomto(pcode_dict)
except (KeyError, IOError):
QMessageBox.information(self.iface.mainWindow(),
"Invalid postcode",
"The postcode you entered was not found")
except IndexError:
pass
def zoomto(self, pcode_dict):
"""Find the coordinates for postcode in the dictionary.
:param pcode_dict:
:return: None
"""
current_crs = self.check_crs()
input_pc = self.toolbar_search.text()
input_pc_fmt = str(input_pc).replace(' ', '').upper()
coords = pcode_dict[input_pc_fmt]
x, y = coords
if current_crs != "EPSG:27700":
cor = (x, y)
point = self.transform(cor)
self.update_canvas(point)
else:
point = (x, y)
self.update_canvas(point)
def update_canvas(self, point):
"""Update the canvas and add vertex marker.
:param point:
:return: None
"""
x, y = point
scale = 120
rect = QgsRectangle(float(x) - scale, float(y) - scale, float(x) + scale, float(y) + scale)
self.canvas.setExtent(rect)
self.marker = QgsVertexMarker(self.canvas)
self.marker.setIconSize(15)
self.marker.setPenWidth(2)
self.marker.setCenter(QgsPointXY(int(x), int(y)))
self.canvas.refresh()
self.canvas.extentsChanged.connect(self.remove_marker)
def remove_marker(self):
"""Remove vertex marker.
:return: None
"""
self.marker.hide()
self.canvas.scene().removeItem(self.marker)
self.canvas.extentsChanged.disconnect(self.remove_marker)
def __init__(self, parent):
super(ProjectData, self).__init__()
self._parent = parent
grid = QGridLayout(self)
grid.addWidget(QLabel(_translate("ProjectData", "Name:")), 0, 0)
self.name = QLineEdit()
if self._parent._item.name == '':
self.name.setText(file_manager.get_basename(
self._parent._item.path))
else:
self.name.setText(self._parent._item.name)
grid.addWidget(self.name, 0, 1)
grid.addWidget(QLabel(_translate("ProjectData", "Project Location:")), 1, 0)
self.txtPath = QLineEdit()
self.txtPath.setReadOnly(True)
self.txtPath.setText(self._parent._item.path)
grid.addWidget(self.txtPath, 1, 1)
grid.addWidget(QLabel(_translate("ProjectData", "Project Type:")), 2, 0)
self.txtType = QLineEdit()
completer = QCompleter(sorted(settings.PROJECT_TYPES))
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.txtType.setCompleter(completer)
self.txtType.setText(self._parent._item.projectType)
grid.addWidget(self.txtType, 2, 1)
grid.addWidget(QLabel(_translate("ProjectData", "Description:")), 3, 0)
self.description = QPlainTextEdit()
self.description.setPlainText(self._parent._item.description)
grid.addWidget(self.description, 3, 1)
grid.addWidget(QLabel(_translate("ProjectData", "URL:")), 4, 0)
self.url = QLineEdit()
self.url.setText(self._parent._item.url)
grid.addWidget(self.url, 4, 1)
grid.addWidget(QLabel(_translate("ProjectData", "Licence:")), 5, 0)
self.cboLicense = QComboBox()
self.cboLicense.addItem('Apache License 2.0')
self.cboLicense.addItem('Artistic License/GPL')
self.cboLicense.addItem('Eclipse Public License 1.0')
self.cboLicense.addItem('GNU General Public License v2')
self.cboLicense.addItem('GNU General Public License v3')
self.cboLicense.addItem('GNU Lesser General Public License')
self.cboLicense.addItem('MIT License')
self.cboLicense.addItem('Mozilla Public License 1.1')
self.cboLicense.addItem('Mozilla Public License 2.0')
self.cboLicense.addItem('New BSD License')
self.cboLicense.addItem('Other Open Source')
self.cboLicense.addItem('Other')
self.cboLicense.setCurrentIndex(4)
index = self.cboLicense.findText(self._parent._item.license)
self.cboLicense.setCurrentIndex(index)
grid.addWidget(self.cboLicense, 5, 1)
self.txtExtensions = QLineEdit()
self.txtExtensions.setText(', '.join(self._parent._item.extensions))
grid.addWidget(QLabel(_translate("ProjectData", "Supported Extensions:")), 6, 0)
grid.addWidget(self.txtExtensions, 6, 1)
grid.addWidget(QLabel(_translate("ProjectData", "Indentation: ")), 7, 0)
self.spinIndentation = QSpinBox()
self.spinIndentation.setValue(self._parent._item.indentation)
self.spinIndentation.setMinimum(1)
grid.addWidget(self.spinIndentation, 7, 1)
self.checkUseTabs = QCheckBox(_translate("ProjectData", "Use Tabs."))
self.checkUseTabs.setChecked(self._parent._item.useTabs)
grid.addWidget(self.checkUseTabs, 7, 2)
class BandupPlotToolWindow(QMainWindow):
def __init__(self):
super(BandupPlotToolWindow, self).__init__()
self.folder_gui_script_is_located = PACKAGE_DIR
try:
if(os.path.isdir(sys.argv[1])):
os.chdir(sys.argv[1])
except IndexError:
pass
self.folder_where_gui_has_been_called = os.getcwd()
plot_script_fname = 'bandup'
self.plot_script = os.path.join(INTERFACE_MAIN_SOURCE_DIR, plot_script_fname)
if(not os.path.isfile(self.plot_script)):
reply = QMessageBox.critical(self,
"Error: BandUP's Plotting script not found",
'The file \n %s file could not be found.'
%(self.plot_script), QMessageBox.Close
)
sys.exit(0)
self.last_folder = QString(self.folder_where_gui_has_been_called)
self.default_aspect_ratio = QString('3/4')
self.vmin = None
self.vmax = None
self.aspect_ratio = None
self.children = []
self.initUI()
def closeEvent(self, evnt):
# Reimplementing closeEvent
for child in self.children:
try:
child.close()
except(RuntimeError):
# In case the child opject has already been deleted, for instance
pass
super(BandupPlotToolWindow, self).closeEvent(evnt)
sys.exit(0)
def default_from_placeholderText(self, obj_name, cast=float):
obj = getattr(self, obj_name)
default = cast(obj.placeholderText())
return default
def try_to_get_plot_boundaries_from_energy_file(self):
self.min_E = None
self.max_E = None
self.min_k = None
self.max_k = None
try:
with open(self.energy_file_path) as energy_info_file:
energy_info_file_lines = energy_info_file.readlines()
try:
self.min_E = float(energy_info_file_lines[1].split()[0])
except(ValueError, IndexError):
pass
try:
self.max_E = float(energy_info_file_lines[2].split()[0])
except(ValueError, IndexError):
pass
try:
self.min_k = float(energy_info_file_lines[1].split()[1])
except(ValueError, IndexError):
pass
try:
self.max_k = float(energy_info_file_lines[2].split()[1])
except(ValueError, IndexError):
pass
try:
self.dE_spinBox.setValue(float(energy_info_file_lines[3].split()[0]))
except(ValueError, IndexError):
pass
except (IOError, TypeError):
pass
if(self.min_k is not None and self.max_k is not None and self.min_k > self.max_k):
self.min_k, self.max_k = self.max_k, self.min_k
if(self.min_E is not None and self.max_E is not None and self.min_E > self.max_E):
self.min_E, self.max_E = self.max_E, self.min_E
if(self.min_E):
self.min_E_lineEdit.setText(str(self.min_E))
if(self.max_E):
self.max_E_lineEdit.setText(str(self.max_E))
if(self.min_k):
self.min_k_lineEdit.setText(str(self.min_k))
if(self.max_k):
self.max_k_lineEdit.setText(str(self.max_k))
def initUI(self):
# Loading the base UI I've created using QT Designer
ui_file = os.path.join(PACKAGE_DIR, 'plot_gui', 'main_window.ui')
uic.loadUi(ui_file, self)
self.setAttribute(QtCore.Qt.WA_DeleteOnClose, True)
# Preventing window from expanding
width = self.frameGeometry().width()
height = self.frameGeometry().height()
self.setMaximumSize(width, height)
self.aspect_ratio_lineEdit.setPlaceholderText(self.default_aspect_ratio)
def set_defualt_file_path(file_lineEdit, trial_file_path):
file_lineEdit.setText('')
trial_file_path = os.path.abspath(str(trial_file_path))
file_exists = os.path.isfile(trial_file_path)
if(file_exists):
file_lineEdit.default_file_path = QString(trial_file_path)
file_lineEdit.default_text = QString('Default: %s' % trial_file_path)
else:
file_lineEdit.default_file_path = None
if(file_lineEdit == self.select_energy_file_lineEdit):
file_lineEdit.default_text = QString('Optional')
else:
file_lineEdit.default_text = QString('Select...')
file_lineEdit.previous_valid_file_path = file_lineEdit.default_file_path
if(len(str(file_lineEdit.default_text)) < 30):
file_lineEdit.setPlaceholderText(file_lineEdit.default_text)
else:
file_lineEdit.setPlaceholderText('...' +
str(file_lineEdit.default_text)[-30:])
# Defaults for the input prim. cell file
set_defualt_file_path(self.select_prim_cell_file_lineEdit,
'prim_cell_lattice.in')
self.prim_cell_file_path = self.select_prim_cell_file_lineEdit.default_file_path
# Defaults for the input pc-kpts file
set_defualt_file_path(self.select_pckpts_file_lineEdit, 'KPOINTS_prim_cell.in')
self.pckpts_file_path = self.select_pckpts_file_lineEdit.default_file_path
# Defaults for the input energy config. file
set_defualt_file_path(self.select_energy_file_lineEdit, 'energy_info.in')
self.energy_file_path = self.select_energy_file_lineEdit.default_file_path
self.try_to_get_plot_boundaries_from_energy_file()
# Defaults for the input EBS file (BandUP's output)
set_defualt_file_path(self.select_EBS_file_lineEdit,
'unfolded_EBS_symmetry-averaged.dat')
self.EBS_file_path = self.select_EBS_file_lineEdit.default_file_path
# Defaults for the out fig. file
self.default_out_figure_file_path = None
self.out_figure_file_path = self.default_out_figure_file_path
self.select_out_figure_file_lineEdit.default_text = (
"Auto, derived from input file"
)
self.select_out_figure_file_lineEdit.setPlaceholderText(
self.select_out_figure_file_lineEdit.default_text
)
self.update_lineEdit_completer()
# Connecting lineEdit objects
self.select_prim_cell_file_lineEdit.editingFinished.connect(
lambda: self.on_editing_input_file_lineEdits(
self.select_prim_cell_file_lineEdit)
)
self.select_pckpts_file_lineEdit.editingFinished.connect(
lambda: self.on_editing_input_file_lineEdits(
self.select_pckpts_file_lineEdit)
)
self.select_energy_file_lineEdit.editingFinished.connect(
lambda: self.on_editing_input_file_lineEdits(
self.select_energy_file_lineEdit)
)
self.select_EBS_file_lineEdit.editingFinished.connect(
lambda: self.on_editing_input_file_lineEdits(
self.select_EBS_file_lineEdit)
)
self.select_out_figure_file_lineEdit.editingFinished.connect(
self.on_editing_output_file_lineEdit
)
self.vmin_lineEdit.editingFinished.connect(self.on_vmin_change)
self.vmax_lineEdit.editingFinished.connect(self.on_vmax_change)
self.aspect_ratio_lineEdit.editingFinished.connect(self.on_aspect_ratio_change)
self.min_E_lineEdit.editingFinished.connect(self.on_min_E_change)
self.max_E_lineEdit.editingFinished.connect(self.on_max_E_change)
self.min_k_lineEdit.editingFinished.connect(self.on_min_k_change)
self.max_k_lineEdit.editingFinished.connect(self.on_max_k_change)
# Connecting the file choice buttons
self.select_prim_cell_file_Button.clicked.connect(
lambda: self.selectFile(self.select_prim_cell_file_Button,
self.select_prim_cell_file_lineEdit)
)
self.select_pckpts_file_Button.clicked.connect(
lambda: self.selectFile(self.select_pckpts_file_Button,
self.select_pckpts_file_lineEdit)
)
self.select_energy_file_Button.clicked.connect(
lambda: self.selectFile(self.select_energy_file_Button,
self.select_energy_file_lineEdit)
)
self.select_EBS_file_Button.clicked.connect(
lambda: self.selectFile(self.select_EBS_file_Button,
self.select_EBS_file_lineEdit)
)
self.select_out_figure_file_Button.clicked.connect(
lambda: self.selectFile(self.select_out_figure_file_Button,
self.select_out_figure_file_lineEdit)
)
# Managing checkBox objects
self.show_colorbar_checkBox.stateChanged.connect(
self.on_show_colorbar_checkBox_stateChanged)
self.show_colorbar_full_label_checkBox.setEnabled(
self.show_colorbar_label_checkBox.isEnabled() and
self.show_colorbar_label_checkBox.isChecked()
)
self.save_figure_checkBox.stateChanged.connect(
self.on_save_figure_checkBox_stateChanged
)
self.show_figure_checkBox.stateChanged.connect(
self.on_show_figure_checkBox_stateChanged
)
# Managing comboBox objects
self.colormap_comboBox.insertItems(1, self.get_available_cmaps(only_names=True))
mpl_colors = sorted(matplotlib.colors.cnames.keys())
self.e_fermi_color_comboBox.insertItems(1, mpl_colors)
self.high_symm_lines_color_comboBox.insertItems(1, mpl_colors)
# Connecting the 'plot' button
self.plot_pushButton.clicked.connect(self.onRun)
# Scheduling the window to be shown at the center of the screen
center_window(self)
self.show()
def get_available_cmaps(self, only_names=False):
return get_available_cmaps(only_names=only_names)
def update_lineEdit_completer(self):
self.files_in_current_folder = [
QString(item) for item in os.listdir(str(self.last_folder)) if
os.path.isfile(os.path.join(str(self.last_folder), item))
]
self.file_lineEdit_completer = QCompleter(self.files_in_current_folder)
self.file_lineEdit_completer.setCompletionMode(QCompleter.InlineCompletion)
self.select_prim_cell_file_lineEdit.setCompleter(self.file_lineEdit_completer)
self.select_pckpts_file_lineEdit.setCompleter(self.file_lineEdit_completer)
self.select_energy_file_lineEdit.setCompleter(self.file_lineEdit_completer)
self.select_EBS_file_lineEdit.setCompleter(self.file_lineEdit_completer)
def on_show_colorbar_checkBox_stateChanged(self):
self.show_colorbar_full_label_checkBox.setEnabled(
self.show_colorbar_label_checkBox.isEnabled() and
self.show_colorbar_label_checkBox.isChecked()
)
def on_save_figure_checkBox_stateChanged(self):
if((not self.save_figure_checkBox.isChecked()) and
(not self.show_figure_checkBox.isChecked())):
self.show_figure_checkBox.setCheckState(QtCore.Qt.Checked)
def on_show_figure_checkBox_stateChanged(self):
if((not self.show_figure_checkBox.isChecked()) and
(not self.save_figure_checkBox.isChecked())):
self.save_figure_checkBox.setCheckState(QtCore.Qt.Checked)
def on_editing_input_file_lineEdits(self, lineEdit):
# This is to make the open/save file dialog screens remember the last folder
os.chdir(str(self.last_folder))
entered_file_path = os.path.abspath(str(lineEdit.text()).strip())
if(entered_file_path.startswith('file:')):
entered_file_path = entered_file_path[5:]
valid_file_entered = os.path.isfile(entered_file_path)
if(valid_file_entered):
file_path = QString(entered_file_path)
lineEdit.previous_valid_file_path = file_path
if(file_path != lineEdit.default_file_path):
lineEdit.setText(file_path)
else:
lineEdit.setText('')
else:
if(str(lineEdit.text()).strip() == ''):
# i.e., if the user resets the lineEdit
lineEdit.previous_valid_file_path = lineEdit.default_file_path
file_path = lineEdit.default_file_path
lineEdit.setText('')
if(lineEdit.default_file_path is not None):
if(len(str(lineEdit.default_file_path)) < 30):
lineEdit.setPlaceholderText(lineEdit.default_file_path)
else:
lineEdit.setPlaceholderText(
'...' + str(lineEdit.default_file_path)[-30:]
)
else:
if(lineEdit == self.select_energy_file_lineEdit):
lineEdit.setPlaceholderText('Optional')
else:
lineEdit.setPlaceholderText('Select...')
else:
if(lineEdit.previous_valid_file_path is not None):
file_path = QString(lineEdit.previous_valid_file_path)
if(lineEdit.previous_valid_file_path != lineEdit.default_file_path):
lineEdit.setText(file_path)
else:
lineEdit.setText('')
if(len(str(lineEdit.default_file_path)) < 30):
lineEdit.setPlaceholderText(lineEdit.default_file_path)
else:
lineEdit.setPlaceholderText(
'...' + str(lineEdit.default_file_path)[-30:]
)
else:
file_path = None
lineEdit.setText('')
if(lineEdit == self.select_energy_file_lineEdit):
lineEdit.setPlaceholderText('Optional')
else:
lineEdit.setPlaceholderText('Select...')
if(lineEdit == self.select_prim_cell_file_lineEdit):
self.prim_cell_file_path = file_path
elif(lineEdit == self.select_pckpts_file_lineEdit):
self.pckpts_file_path = file_path
elif(lineEdit == self.select_energy_file_lineEdit):
self.energy_file_path = file_path
elif(lineEdit == self.select_EBS_file_lineEdit):
self.EBS_file_path = file_path
def on_editing_output_file_lineEdit(self):
# lineEdit.isModified() returns False unless the text has been manually
# changed by the user
if(not self.select_out_figure_file_lineEdit.isModified()):
return
current_file_path = self.out_figure_file_path
new_file_path = str(self.select_out_figure_file_lineEdit.text()).strip(' .')
if(new_file_path.startswith('file:')):
new_file_path = new_file_path[5:]
if(new_file_path == ''):
self.out_figure_file_path = None
self.select_out_figure_file_lineEdit.setText('')
self.select_out_figure_file_lineEdit.setPlaceholderText(
self.select_out_figure_file_lineEdit.default_text
)
return
file_format_is_valid = False
for ext in allowed_fig_formats():
if(new_file_path.lower().endswith(ext)):
file_format_is_valid = True
break
if(not file_format_is_valid):
new_file_path = (new_file_path.strip() +
'.' + set_default_fig_format(allowed_fig_formats())
)
new_file_path = os.path.abspath(new_file_path)
file_exists = os.path.isfile(new_file_path)
is_directory = os.path.isdir(new_file_path)
if(file_exists or is_directory):
reply = QMessageBox.question(self, ' ',
'File "%s" exists. Overwrite?' % new_file_path,
QMessageBox.Yes | QMessageBox.No,
QMessageBox.No
)
if reply == QMessageBox.Yes:
self.out_figure_file_path = QString(new_file_path)
else:
if self.out_figure_file_path is not None:
if(str(new_file_path) == str(self.out_figure_file_path)):
self.out_figure_file_path = None
else:
self.out_figure_file_path = QString(self.out_figure_file_path)
else:
self.out_figure_file_path = QString(new_file_path)
if(self.out_figure_file_path is not None):
self.select_out_figure_file_lineEdit.setText(self.out_figure_file_path)
else:
self.select_out_figure_file_lineEdit.setText('')
self.select_out_figure_file_lineEdit.setPlaceholderText(
self.select_out_figure_file_lineEdit.default_text
)
return
def on_aspect_ratio_change(self):
try:
new_ar = QString(str(abs(
Fraction(str(self.aspect_ratio_lineEdit.text())).limit_denominator(
max_denominator=99
)
)))
if(new_ar == self.default_aspect_ratio):
new_ar = None
except (SyntaxError, ValueError):
if(str(self.aspect_ratio_lineEdit.text()).strip() == ''):
new_ar = None
else:
new_ar = self.aspect_ratio
except ZeroDivisionError:
new_ar = None
self.aspect_ratio = new_ar
if(self.aspect_ratio is None):
self.aspect_ratio_lineEdit.setText('')
# The next line might look a bit odd, but it's part of the trick to
# overcome the lack of placeholder text in Qt4.6 and lower
self.aspect_ratio_lineEdit.setPlaceholderText(
self.aspect_ratio_lineEdit.PlaceholderText()
)
else:
self.aspect_ratio_lineEdit.setText(new_ar)
def __validated_numeric_lineEdit(self, lineEdit, current_value,
lower_bound=float("-inf"),upper_bound=float("inf")):
try:
new_value = float(lineEdit.text())
if(((lower_bound is not None) and (new_value <= lower_bound)) or
((upper_bound is not None) and (new_value >= upper_bound))):
raise ValueError
except ValueError:
if(str(lineEdit.text()).strip() == ''): # If user resets lineEdit
new_value = None
else:
new_value = current_value
if(new_value is None):
lineEdit.setText('')
# The next line might look a bit odd, but it's part of the trick to
# overcome the lack of placeholder text in Qt4.6 and lower
lineEdit.setPlaceholderText(lineEdit.PlaceholderText())
else:
lineEdit.setText(str(new_value))
return new_value
def on_vmin_change(self):
self.vmin = self.__validated_numeric_lineEdit(
self.vmin_lineEdit, self.vmin, upper_bound=self.vmax
)
def on_vmax_change(self):
self.vmax = self.__validated_numeric_lineEdit(
self.vmax_lineEdit, self.vmax, lower_bound=self.vmin
)
def on_min_E_change(self):
self.min_E = self.__validated_numeric_lineEdit(
self.min_E_lineEdit, self.min_E, upper_bound=self.max_E
)
def on_max_E_change(self):
self.max_E = self.__validated_numeric_lineEdit(
self.max_E_lineEdit, self.max_E, lower_bound=self.min_E
)
def on_min_k_change(self):
self.min_k = self.__validated_numeric_lineEdit(
self.min_k_lineEdit, self.min_k, upper_bound=self.max_k
)
def on_max_k_change(self):
self.max_k = self.__validated_numeric_lineEdit(
self.max_k_lineEdit, self.max_k, lower_bound=self.min_k
)
def selectFile(self, button, lineEdit):
# This is to make the open/save file dialog screens remember the last folder
os.chdir(str(self.last_folder))
if(button == self.select_out_figure_file_Button):
if(self.default_out_figure_file_path):
default_out_figure_file_path = self.default_out_figure_file_path
else:
default_output_file_name = (
'plot_EBS_BandUP.' +
set_default_fig_format(allowed_fig_formats())
)
allowed_file_types_string = (
"Images (*." + " *.".join(allowed_fig_formats()) + ")"
)
file_path = str(QFileDialog.getSaveFileName(self, self.windowTitle() +
' - Save file', default_output_file_name,
allowed_file_types_string
)
)
if(file_path.strip()):
self.out_figure_file_path = QString(file_path)
# setText does NOT send a 'textEdited' signal.
# It only sends 'textChanged'
lineEdit.setText(self.out_figure_file_path)
else:
file_path = str(QFileDialog.getOpenFileName(self, self.windowTitle() +
' - Select file')[0])
file_path = os.path.abspath(file_path)
file_exists = os.path.isfile(file_path)
is_directory = os.path.isdir(file_path)
if(file_exists and not is_directory):
lineEdit.setText(file_path)
lineEdit.previous_valid_file_path = QString(file_path)
if(button == self.select_EBS_file_Button):
self.EBS_file_path = file_path
elif(button == self.select_prim_cell_file_Button):
self.prim_cell_file_path = file_path
elif(button == self.select_pckpts_file_Button):
self.pckpts_file_path = file_path
elif(button == self.select_energy_file_Button):
self.energy_file_path = file_path
if(os.path.dirname(file_path).strip() and not is_directory):
self.last_folder = QString(os.path.dirname(file_path))
self.update_lineEdit_completer()
def onRun(self):
args_for_plotting_tool = []
# pushButton objects, input and output files
def warn_file_not_selected(filetype):
reply = QMessageBox.warning(self, ' ',
'The %s file could not be found.'%(
filetype, QMessageBox.Ok))
if(os.path.isfile(str(self.EBS_file_path).strip())):
args_for_plotting_tool += ['-input_file', self.EBS_file_path]
else:
warn_file_not_selected("EBS (BandUP's output)")
return
if(self.out_figure_file_path):
args_for_plotting_tool.append(self.out_figure_file_path)
if(os.path.isfile(str(self.prim_cell_file_path))):
args_for_plotting_tool += ['-pc_file', self.prim_cell_file_path]
else:
warn_file_not_selected('primitive cell')
return
if(os.path.isfile(str(self.pckpts_file_path))):
args_for_plotting_tool += ['--kpoints_file', self.pckpts_file_path]
else:
warn_file_not_selected('pc-kpts file')
return
if(self.energy_file_path is not None):
if(os.path.isfile(str(self.energy_file_path))):
args_for_plotting_tool += ['-efile', self.energy_file_path]
else:
warn_file_not_selected('energy grid configuration file')
return
# comboBox objects
if(lower_QString(self.colormap_comboBox.currentText()) != 'default'):
args_for_plotting_tool += ['-cmap', self.colormap_comboBox.currentText()]
if(lower_QString(self.e_fermi_color_comboBox.currentText()) != 'default'):
args_for_plotting_tool += ['--e_fermi_linecolor',
self.e_fermi_color_comboBox.currentText()]
if(lower_QString(self.high_symm_lines_color_comboBox.currentText())!='default'):
args_for_plotting_tool += ['--high_symm_linecolor',
self.high_symm_lines_color_comboBox.currentText()]
args_for_plotting_tool += ['-res',
lower_QString(self.fig_resolution_comboBox.currentText()[0])]
args_for_plotting_tool += ['--interpolation',
lower_QString(self.interpolation_comboBox.currentText())]
args_for_plotting_tool.append('--'+
lower_QString(self.fig_orientation_comboBox.currentText()))
args_for_plotting_tool += ['--line_style_high_symm_points',
lower_QString(self.high_symm_lines_style_comboBox.currentText())]
args_for_plotting_tool += ['--line_style_E_f',
lower_QString(self.e_fermi_line_style_comboBox.currentText())]
# spinBox objects
args_for_plotting_tool += ['--n_levels', self.n_levels_spinBox.text()]
if(self.show_colorbar_checkBox.isChecked()):
args_for_plotting_tool += ['--round_cb',
self.decimal_digits_cb_spinBox.text()]
try:
args_for_plotting_tool += ['--line_width_E_f',
float(self.e_fermi_linewidth_SpinBox.text())]
except ValueError:
pass
try:
args_for_plotting_tool += ['--line_width_high_symm_points',
float(self.high_symm_linewidth_SpinBox.text())]
except ValueError:
pass
# lineEdit objects
if(self.aspect_ratio):
args_for_plotting_tool += ['--aspect_ratio', self.aspect_ratio]
else:
args_for_plotting_tool += ['--aspect_ratio', self.default_aspect_ratio]
if(self.vmin): args_for_plotting_tool += ['-vmin', self.vmin]
if(self.vmax): args_for_plotting_tool += ['-vmax', self.vmax]
if(not '-efile' in args_for_plotting_tool):
if(self.min_E is None):
args_for_plotting_tool += ['-emin',
self.default_from_placeholderText('min_E_lineEdit')]
else:
args_for_plotting_tool += ['-emin', self.min_E]
if(self.max_E is None):
args_for_plotting_tool += ['-emax',
self.default_from_placeholderText('max_E_lineEdit')]
else:
args_for_plotting_tool += ['-emax', self.max_E]
args_for_plotting_tool += ['-dE', float(self.dE_spinBox.text())]
if(self.min_k): args_for_plotting_tool += ['-kmin', self.min_k]
if(self.max_k): args_for_plotting_tool += ['-kmax', self.max_k]
# CheckBoxes
if(self.show_figure_checkBox.isChecked()):
args_for_plotting_tool.append('--show')
if(self.save_figure_checkBox.isChecked()):
if(self.open_saved_file_checkBox.isChecked()):
args_for_plotting_tool.append('--saveshow')
else:
args_for_plotting_tool.append('--save')
if(not self.draw_e_fermi_checkBox.isChecked()):
args_for_plotting_tool.append('--no_ef')
if(not self.draw_hygh_symm_kpts_lines_checkBox.isChecked()):
args_for_plotting_tool.append('--no_symm_lines')
if(not self.draw_high_symm_kpts_labels_checkBox.isChecked()):
args_for_plotting_tool.append('--no_symm_labels')
if(self.show_colorbar_checkBox.isChecked()):
if(self.show_colorbar_label_checkBox.isChecked()):
if(self.show_colorbar_full_label_checkBox.isChecked()):
args_for_plotting_tool.append('--cb_label_full')
else:
args_for_plotting_tool.append('--cb_label')
else:
args_for_plotting_tool.append('--no_cb')
# Running
os.chdir(str(self.folder_where_gui_has_been_called))
plot_argv = (['plot'] +
[str(arg) for arg in args_for_plotting_tool] +
['--running_from_GUI'])
run_as_external = False
if(run_as_external):
plot_argv = [self.plot_script] + plot_argv
qProcess = MyQProcess(parent=self,
output_window_title=self.windowTitle() + ' - Output')
qProcess.start(' '.join(plot_argv))
else:
plot_parser = BandUpPythonArgumentParser()
plot_args = plot_parser.parse_args(plot_argv)
self.out_window = MyOutputWindow()
self.children.append(self.out_window)
self.plot = make_plot(plot_args)
class HelpWebSearchWidget(E5ClearableLineEdit):
"""
Class implementing a web search widget for the web browser.
@signal search(QUrl) emitted when the search should be done
"""
search = pyqtSignal(QUrl)
def __init__(self, parent=None):
"""
Constructor
@param parent reference to the parent widget (QWidget)
"""
super(HelpWebSearchWidget, self).__init__(parent)
from E5Gui.E5LineEdit import E5LineEdit
from E5Gui.E5LineEditButton import E5LineEditButton
from .OpenSearch.OpenSearchManager import OpenSearchManager
self.__mw = parent
self.__openSearchManager = OpenSearchManager(self)
self.__openSearchManager.currentEngineChanged.connect(
self.__currentEngineChanged)
self.__currentEngine = ""
self.__enginesMenu = QMenu(self)
self.__engineButton = E5LineEditButton(self)
self.__engineButton.setMenu(self.__enginesMenu)
self.addWidget(self.__engineButton, E5LineEdit.LeftSide)
self.__searchButton = E5LineEditButton(self)
self.__searchButton.setIcon(UI.PixmapCache.getIcon("webSearch.png"))
self.addWidget(self.__searchButton, E5LineEdit.LeftSide)
self.__model = QStandardItemModel(self)
self.__completer = QCompleter()
self.__completer.setModel(self.__model)
self.__completer.setCompletionMode(
QCompleter.UnfilteredPopupCompletion)
self.__completer.setWidget(self)
self.__searchButton.clicked.connect(self.__searchButtonClicked)
self.textEdited.connect(self.__textEdited)
self.returnPressed.connect(self.__searchNow)
self.__completer.activated[QModelIndex].connect(
self.__completerActivated)
self.__completer.highlighted[QModelIndex].connect(
self.__completerHighlighted)
self.__enginesMenu.aboutToShow.connect(self.__showEnginesMenu)
self.__suggestionsItem = None
self.__suggestions = []
self.__suggestTimer = None
self.__suggestionsEnabled = Preferences.getHelp("WebSearchSuggestions")
self.__recentSearchesItem = None
self.__recentSearches = []
self.__maxSavedSearches = 10
self.__engine = None
self.__loadSearches()
self.__setupCompleterMenu()
self.__currentEngineChanged()
def __searchNow(self):
"""
Private slot to perform the web search.
"""
searchText = self.text()
if not searchText:
return
globalSettings = QWebSettings.globalSettings()
if not globalSettings.testAttribute(
QWebSettings.PrivateBrowsingEnabled):
if searchText in self.__recentSearches:
self.__recentSearches.remove(searchText)
self.__recentSearches.insert(0, searchText)
if len(self.__recentSearches) > self.__maxSavedSearches:
self.__recentSearches = \
self.__recentSearches[:self.__maxSavedSearches]
self.__setupCompleterMenu()
url = self.__openSearchManager.currentEngine().searchUrl(searchText)
self.search.emit(url)
def __setupCompleterMenu(self):
"""
Private method to create the completer menu.
"""
if not self.__suggestions or \
(self.__model.rowCount() > 0 and
self.__model.item(0) != self.__suggestionsItem):
self.__model.clear()
self.__suggestionsItem = None
else:
self.__model.removeRows(1, self.__model.rowCount() - 1)
boldFont = QFont()
boldFont.setBold(True)
if self.__suggestions:
if self.__model.rowCount() == 0:
if not self.__suggestionsItem:
self.__suggestionsItem = QStandardItem(
self.tr("Suggestions"))
self.__suggestionsItem.setFont(boldFont)
self.__model.appendRow(self.__suggestionsItem)
for suggestion in self.__suggestions:
self.__model.appendRow(QStandardItem(suggestion))
if not self.__recentSearches:
self.__recentSearchesItem = QStandardItem(
self.tr("No Recent Searches"))
self.__recentSearchesItem.setFont(boldFont)
self.__model.appendRow(self.__recentSearchesItem)
else:
self.__recentSearchesItem = QStandardItem(
self.tr("Recent Searches"))
self.__recentSearchesItem.setFont(boldFont)
self.__model.appendRow(self.__recentSearchesItem)
for recentSearch in self.__recentSearches:
self.__model.appendRow(QStandardItem(recentSearch))
view = self.__completer.popup()
view.setFixedHeight(view.sizeHintForRow(0) * self.__model.rowCount() +
view.frameWidth() * 2)
self.__searchButton.setEnabled(
bool(self.__recentSearches or self.__suggestions))
def __completerActivated(self, index):
"""
Private slot handling the selection of an entry from the completer.
@param index index of the item (QModelIndex)
"""
if self.__suggestionsItem and \
self.__suggestionsItem.index().row() == index.row():
return
if self.__recentSearchesItem and \
self.__recentSearchesItem.index().row() == index.row():
return
self.__searchNow()
def __completerHighlighted(self, index):
"""
Private slot handling the highlighting of an entry of the completer.
@param index index of the item (QModelIndex)
@return flah indicating a successful highlighting (boolean)
"""
if self.__suggestionsItem and \
self.__suggestionsItem.index().row() == index.row():
return False
if self.__recentSearchesItem and \
self.__recentSearchesItem.index().row() == index.row():
return False
self.setText(index.data())
return True
def __textEdited(self, txt):
"""
Private slot to handle changes of the search text.
@param txt search text (string)
"""
if self.__suggestionsEnabled:
if self.__suggestTimer is None:
self.__suggestTimer = QTimer(self)
self.__suggestTimer.setSingleShot(True)
self.__suggestTimer.setInterval(200)
self.__suggestTimer.timeout.connect(self.__getSuggestions)
self.__suggestTimer.start()
else:
self.__completer.setCompletionPrefix(txt)
self.__completer.complete()
def __getSuggestions(self):
"""
Private slot to get search suggestions from the configured search
engine.
"""
searchText = self.text()
if searchText:
self.__openSearchManager.currentEngine()\
.requestSuggestions(searchText)
def __newSuggestions(self, suggestions):
"""
Private slot to receive a new list of suggestions.
@param suggestions list of suggestions (list of strings)
"""
self.__suggestions = suggestions
self.__setupCompleterMenu()
self.__completer.complete()
def __showEnginesMenu(self):
"""
Private slot to handle the display of the engines menu.
"""
self.__enginesMenu.clear()
from .OpenSearch.OpenSearchEngineAction import OpenSearchEngineAction
engineNames = self.__openSearchManager.allEnginesNames()
for engineName in engineNames:
engine = self.__openSearchManager.engine(engineName)
action = OpenSearchEngineAction(engine, self.__enginesMenu)
action.setData(engineName)
action.triggered.connect(self.__changeCurrentEngine)
self.__enginesMenu.addAction(action)
if self.__openSearchManager.currentEngineName() == engineName:
action.setCheckable(True)
action.setChecked(True)
ct = self.__mw.currentBrowser()
linkedResources = ct.linkedResources("search")
if len(linkedResources) > 0:
self.__enginesMenu.addSeparator()
for linkedResource in linkedResources:
url = QUrl(linkedResource.href)
title = linkedResource.title
mimetype = linkedResource.type_
if mimetype != "application/opensearchdescription+xml":
continue
if url.isEmpty():
continue
if url.isRelative():
url = ct.url().resolved(url)
if not title:
if not ct.title():
title = url.host()
else:
title = ct.title()
action = self.__enginesMenu.addAction(
self.tr("Add '{0}'").format(title),
self.__addEngineFromUrl)
action.setData(url)
action.setIcon(ct.icon())
self.__enginesMenu.addSeparator()
self.__enginesMenu.addAction(self.__mw.searchEnginesAction())
if self.__recentSearches:
self.__enginesMenu.addAction(self.tr("Clear Recent Searches"),
self.clear)
def __changeCurrentEngine(self):
"""
Private slot to handle the selection of a search engine.
"""
action = self.sender()
if action is not None:
name = action.data()
self.__openSearchManager.setCurrentEngineName(name)
def __addEngineFromUrl(self):
"""
Private slot to add a search engine given its URL.
"""
action = self.sender()
if action is not None:
url = action.data()
if not isinstance(url, QUrl):
return
self.__openSearchManager.addEngine(url)
def __searchButtonClicked(self):
"""
Private slot to show the search menu via the search button.
"""
self.__setupCompleterMenu()
self.__completer.complete()
def clear(self):
"""
Public method to clear all private data.
"""
self.__recentSearches = []
self.__setupCompleterMenu()
super(HelpWebSearchWidget, self).clear()
self.clearFocus()
def preferencesChanged(self):
"""
Public method to handle the change of preferences.
"""
self.__suggestionsEnabled = Preferences.getHelp("WebSearchSuggestions")
if not self.__suggestionsEnabled:
self.__suggestions = []
self.__setupCompleterMenu()
def saveSearches(self):
"""
Public method to save the recently performed web searches.
"""
Preferences.Prefs.settings.setValue(
'Help/WebSearches', self.__recentSearches)
def __loadSearches(self):
"""
Private method to load the recently performed web searches.
"""
searches = Preferences.Prefs.settings.value('Help/WebSearches')
if searches is not None:
self.__recentSearches = searches
def openSearchManager(self):
"""
Public method to get a reference to the opensearch manager object.
@return reference to the opensearch manager object (OpenSearchManager)
"""
return self.__openSearchManager
def __currentEngineChanged(self):
"""
Private slot to track a change of the current search engine.
"""
if self.__openSearchManager.engineExists(self.__currentEngine):
oldEngine = self.__openSearchManager.engine(self.__currentEngine)
oldEngine.imageChanged.disconnect(self.__engineImageChanged)
if self.__suggestionsEnabled:
oldEngine.suggestions.disconnect(self.__newSuggestions)
newEngine = self.__openSearchManager.currentEngine()
if newEngine.networkAccessManager() is None:
newEngine.setNetworkAccessManager(self.__mw.networkAccessManager())
newEngine.imageChanged.connect(self.__engineImageChanged)
if self.__suggestionsEnabled:
newEngine.suggestions.connect(self.__newSuggestions)
self.setInactiveText(self.__openSearchManager.currentEngineName())
self.__currentEngine = self.__openSearchManager.currentEngineName()
self.__engineButton.setIcon(QIcon(QPixmap.fromImage(
self.__openSearchManager.currentEngine().image())))
self.__suggestions = []
self.__setupCompleterMenu()
def __engineImageChanged(self):
"""
Private slot to handle a change of the current search engine icon.
"""
self.__engineButton.setIcon(QIcon(QPixmap.fromImage(
self.__openSearchManager.currentEngine().image())))
def mousePressEvent(self, evt):
"""
Protected method called by a mouse press event.
@param evt reference to the mouse event (QMouseEvent)
"""
if evt.button() == Qt.XButton1:
self.__mw.currentBrowser().pageAction(QWebPage.Back).trigger()
elif evt.button() == Qt.XButton2:
self.__mw.currentBrowser().pageAction(QWebPage.Forward).trigger()
else:
super(HelpWebSearchWidget, self).mousePressEvent(evt)
def __init__(self, core_args=None, core_env=None, api_port=None):
QMainWindow.__init__(self)
QCoreApplication.setOrganizationDomain("nl")
QCoreApplication.setOrganizationName("TUDelft")
QCoreApplication.setApplicationName("Tribler")
QCoreApplication.setAttribute(Qt.AA_UseHighDpiPixmaps)
self.gui_settings = QSettings()
api_port = api_port or int(get_gui_setting(self.gui_settings, "api_port", DEFAULT_API_PORT))
dispatcher.update_worker_settings(port=api_port)
self.navigation_stack = []
self.tribler_started = False
self.tribler_settings = None
self.debug_window = None
self.core_manager = CoreManager(api_port)
self.pending_requests = {}
self.pending_uri_requests = []
self.download_uri = None
self.dialog = None
self.new_version_dialog = None
self.start_download_dialog_active = False
self.request_mgr = None
self.search_request_mgr = None
self.search_suggestion_mgr = None
self.selected_torrent_files = []
self.vlc_available = True
self.has_search_results = False
self.last_search_query = None
self.last_search_time = None
self.start_time = time.time()
self.exception_handler_called = False
self.token_refresh_timer = None
self.shutdown_timer = None
self.add_torrent_url_dialog_active = False
sys.excepthook = self.on_exception
uic.loadUi(get_ui_file_path('mainwindow.ui'), self)
TriblerRequestManager.window = self
self.tribler_status_bar.hide()
self.token_balance_widget.mouseReleaseEvent = self.on_token_balance_click
def on_state_update(new_state):
self.loading_text_label.setText(new_state)
self.core_manager.core_state_update.connect(on_state_update)
self.magnet_handler = MagnetHandler(self.window)
QDesktopServices.setUrlHandler("magnet", self.magnet_handler, "on_open_magnet_link")
self.debug_pane_shortcut = QShortcut(QKeySequence("Ctrl+d"), self)
self.debug_pane_shortcut.activated.connect(self.clicked_menu_button_debug)
self.import_torrent_shortcut = QShortcut(QKeySequence("Ctrl+o"), self)
self.import_torrent_shortcut.activated.connect(self.on_add_torrent_browse_file)
self.add_torrent_url_shortcut = QShortcut(QKeySequence("Ctrl+i"), self)
self.add_torrent_url_shortcut.activated.connect(self.on_add_torrent_from_url)
# Remove the focus rect on OS X
for widget in self.findChildren(QLineEdit) + self.findChildren(QListWidget) + self.findChildren(QTreeWidget):
widget.setAttribute(Qt.WA_MacShowFocusRect, 0)
self.menu_buttons = [self.left_menu_button_home, self.left_menu_button_search, self.left_menu_button_my_channel,
self.left_menu_button_subscriptions, self.left_menu_button_video_player,
self.left_menu_button_downloads, self.left_menu_button_discovered]
self.video_player_page.initialize_player()
self.search_results_page.initialize_search_results_page(self.gui_settings)
self.settings_page.initialize_settings_page()
self.subscribed_channels_page.initialize()
self.edit_channel_page.initialize_edit_channel_page(self.gui_settings)
self.downloads_page.initialize_downloads_page()
self.home_page.initialize_home_page()
self.loading_page.initialize_loading_page()
self.discovering_page.initialize_discovering_page()
self.discovered_page.initialize_discovered_page(self.gui_settings)
self.channel_page.initialize_channel_page(self.gui_settings)
self.trust_page.initialize_trust_page()
self.token_mining_page.initialize_token_mining_page()
self.stackedWidget.setCurrentIndex(PAGE_LOADING)
# Create the system tray icon
if QSystemTrayIcon.isSystemTrayAvailable():
self.tray_icon = QSystemTrayIcon()
use_monochrome_icon = get_gui_setting(self.gui_settings, "use_monochrome_icon", False, is_bool=True)
self.update_tray_icon(use_monochrome_icon)
# Create the tray icon menu
menu = self.create_add_torrent_menu()
show_downloads_action = QAction('Show downloads', self)
show_downloads_action.triggered.connect(self.clicked_menu_button_downloads)
token_balance_action = QAction('Show token balance', self)
token_balance_action.triggered.connect(lambda: self.on_token_balance_click(None))
quit_action = QAction('Quit Tribler', self)
quit_action.triggered.connect(self.close_tribler)
menu.addSeparator()
menu.addAction(show_downloads_action)
menu.addAction(token_balance_action)
menu.addSeparator()
menu.addAction(quit_action)
self.tray_icon.setContextMenu(menu)
else:
self.tray_icon = None
self.hide_left_menu_playlist()
self.left_menu_button_debug.setHidden(True)
self.top_menu_button.setHidden(True)
self.left_menu.setHidden(True)
self.token_balance_widget.setHidden(True)
self.settings_button.setHidden(True)
self.add_torrent_button.setHidden(True)
self.top_search_bar.setHidden(True)
# Set various icons
self.top_menu_button.setIcon(QIcon(get_image_path('menu.png')))
self.search_completion_model = QStringListModel()
completer = QCompleter()
completer.setModel(self.search_completion_model)
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.item_delegate = QStyledItemDelegate()
completer.popup().setItemDelegate(self.item_delegate)
completer.popup().setStyleSheet("""
QListView {
background-color: #404040;
}
QListView::item {
color: #D0D0D0;
padding-top: 5px;
padding-bottom: 5px;
}
QListView::item:hover {
background-color: #707070;
}
""")
self.top_search_bar.setCompleter(completer)
# Toggle debug if developer mode is enabled
self.window().left_menu_button_debug.setHidden(
not get_gui_setting(self.gui_settings, "debug", False, is_bool=True))
# Start Tribler
self.core_manager.start(core_args=core_args, core_env=core_env)
self.core_manager.events_manager.torrent_finished.connect(self.on_torrent_finished)
self.core_manager.events_manager.new_version_available.connect(self.on_new_version_available)
self.core_manager.events_manager.tribler_started.connect(self.on_tribler_started)
self.core_manager.events_manager.events_started.connect(self.on_events_started)
self.core_manager.events_manager.low_storage_signal.connect(self.on_low_storage)
self.core_manager.events_manager.credit_mining_signal.connect(self.on_credit_mining_error)
self.core_manager.events_manager.tribler_shutdown_signal.connect(self.on_tribler_shutdown_state_update)
self.core_manager.events_manager.upgrader_tick.connect(
lambda text: self.show_status_bar("Upgrading Tribler database: " + text))
self.core_manager.events_manager.upgrader_finished.connect(
lambda _: self.hide_status_bar())
self.core_manager.events_manager.received_search_result.connect(
self.search_results_page.received_search_result)
# Install signal handler for ctrl+c events
def sigint_handler(*_):
self.close_tribler()
signal.signal(signal.SIGINT, sigint_handler)
self.installEventFilter(self.video_player_page)
# Resize the window according to the settings
center = QApplication.desktop().availableGeometry(self).center()
pos = self.gui_settings.value("pos", QPoint(center.x() - self.width() * 0.5, center.y() - self.height() * 0.5))
size = self.gui_settings.value("size", self.size())
self.move(pos)
self.resize(size)
self.show()
def __init__(self, parent):
super(ProjectData, self).__init__()
self._parent = parent
grid = QGridLayout(self)
grid.addWidget(QLabel(translations.TR_PROJECT_NAME), 0, 0)
self._line_name = QLineEdit()
if not len(self._parent.project.name):
self._line_name.setText(file_manager.get_basename(
self._parent.project.path))
else:
self._line_name.setText(self._parent.project.name)
grid.addWidget(self._line_name, 0, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_LOCATION), 1, 0)
self.line_path = QLineEdit()
self.line_path.setReadOnly(True)
self.line_path.setText(self._parent.project.path)
grid.addWidget(self.line_path, 1, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_TYPE), 2, 0)
self.line_type = QLineEdit()
template_registry = IDE.get_service("template_registry")
completer = QCompleter(template_registry.list_project_categories())
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.line_type.setCompleter(completer)
self.line_type.setPlaceholderText("python")
self.line_type.setText(self._parent.project.project_type)
grid.addWidget(self.line_type, 2, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_DESCRIPTION), 3, 0)
self._line_description = QPlainTextEdit()
self._line_description.setPlainText(self._parent.project.description)
grid.addWidget(self._line_description, 3, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_URL), 4, 0)
self._line_url = QLineEdit()
self._line_url.setText(self._parent.project.url)
self._line_url.setPlaceholderText(
'https://www.{}.com'.format(getuser()))
grid.addWidget(self._line_url, 4, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_LICENSE), 5, 0)
self._combo_license = QComboBox()
self._combo_license.addItems(LICENSES)
self._combo_license.setCurrentIndex(12)
index = self._combo_license.findText(self._parent.project.license)
self._combo_license.setCurrentIndex(index)
grid.addWidget(self._combo_license, 5, 1)
self._line_extensions = QLineEdit()
self._line_extensions.setText(
', '.join(self._parent.project.extensions))
self._line_extensions.setToolTip(
translations.TR_PROJECT_EXTENSIONS_TOOLTIP)
grid.addWidget(QLabel(translations.TR_PROJECT_EXTENSIONS), 6, 0)
grid.addWidget(self._line_extensions, 6, 1)
labelTooltip = QLabel(translations.TR_PROJECT_EXTENSIONS_INSTRUCTIONS)
grid.addWidget(labelTooltip, 7, 1)
grid.addWidget(QLabel(translations.TR_PROJECT_INDENTATION), 8, 0)
self._spin_indentation = QSpinBox()
self._spin_indentation.setValue(self._parent.project.indentation)
self._spin_indentation.setRange(2, 10)
self._spin_indentation.setValue(4)
self._spin_indentation.setSingleStep(2)
grid.addWidget(self._spin_indentation, 8, 1)
self._combo_tabs_or_spaces = QComboBox()
self._combo_tabs_or_spaces.addItems([
translations.TR_PREFERENCES_EDITOR_CONFIG_SPACES.capitalize(),
translations.TR_PREFERENCES_EDITOR_CONFIG_TABS.capitalize()])
self._combo_tabs_or_spaces.setCurrentIndex(
int(self._parent.project.use_tabs))
grid.addWidget(self._combo_tabs_or_spaces, 9, 1)
