def available_db_combo(self):
db_files = []
db_list_model = QStringListModel()
for subdir, dirs, files in os.walk(os.path.dirname(os.path.realpath(__file__))):
for file in files:
filepath = subdir + os.path.sep + file
if filepath.endswith(".db"):
if filepath not in db_files:
db_files.append(file[:-3])
db_list_model.setStringList(db_files)
return db_list_model.stringList()
class LabelConfigurator(QDialog):
def __init__(self, boxManager, spawnPos):
super().__init__()
# Variables
self.spawnPos = spawnPos
# Objects
self.boxManager = boxManager
self.layout = QVBoxLayout(self)
self.contentLayout = QHBoxLayout()
self.settingsLayout = QVBoxLayout()
self.isOccludedButton = Check('Occluded',
boxManager.getRecentIsOccluded())
self.isTruncatedButton = Check('Truncated',
boxManager.getRecentIsTruncated())
self.isGroupOfButton = Check('Group Of',
boxManager.getRecentIsGroupOf())
self.isDepictionButton = Check('Depiction',
boxManager.getRecentIsDepiction())
self.isInsideButton = Check('Inside', boxManager.getRecentIsInside())
self.acceptButton = QPushButton('Accept')
self.cancelButton = QPushButton('Cancel')
self.labelsModel = QStringListModel()
self.labelsView = QListView()
# Layout
self.setWindowFlags(Qt.Popup)
self.settingsLayout.setAlignment(Qt.AlignTop | Qt.AlignCenter)
self.settingsLayout.setMargin(0)
self.settingsLayout.addWidget(self.isOccludedButton)
self.settingsLayout.addWidget(self.isTruncatedButton)
self.settingsLayout.addWidget(self.isGroupOfButton)
self.settingsLayout.addWidget(self.isDepictionButton)
self.settingsLayout.addWidget(self.isInsideButton)
self.settingsLayout.addStretch(1)
self.settingsLayout.addWidget(self.acceptButton)
self.settingsLayout.addWidget(self.cancelButton)
self.contentLayout.addWidget(self.labelsView)
self.contentLayout.addLayout(self.settingsLayout)
self.layout.addLayout(self.contentLayout)
# Styling
self.setStyleSheet('LabelConfigurator { '
'background-color: ' + ThemeManager.BG_L1 + ';'
'border-top-left-radius: ' +
str(ThemeManager.CURVE) + 'px;'
'border-bottom-left-radius: ' +
str(ThemeManager.CURVE) + 'px;'
'border-top-right-radius: ' +
str(ThemeManager.CURVE) + 'px;'
'border-bottom-right-radius: ' +
str(ThemeManager.CURVE) + 'px;'
'border-width: 0px;'
'border-style: solid;'
'}'
'QPushButton {'
'background-color: ' + ThemeManager.BG_L2 + ';'
'border-radius: 10px;'
'color: ' + ThemeManager.LABEL + ';'
'font-size: 14px;'
'}'
'QPushButton:hover {'
'background-color: ' + ThemeManager.BG_L3 + ';'
'}'
'QListView { '
'background-color: ' + ThemeManager.BG_L2 + ';'
'}')
self.layout.setMargin(20)
self.layout.setSpacing(10)
self.contentLayout.setMargin(0)
self.labelsModel.setStringList(boxManager.loadLabels())
self.labelsView.setFixedWidth(80)
self.labelsView.setFrameStyle(QFrame.NoFrame)
self.labelsView.setModel(self.labelsModel)
self.labelsView.setItemDelegate(ListDelegate.ListDelegate())
index = None
try:
row = self.labelsModel.stringList().index(
boxManager.getRecentLabelName())
index = self.labelsModel.index(row)
except ValueError:
index = self.labelsModel.index(0)
if index is not None:
self.labelsView.setCurrentIndex(index)
# Connections
self.acceptButton.clicked.connect(self.close)
self.cancelButton.clicked.connect(self.reject)
def showEvent(self, event):
super().showEvent(event)
self.move(self.spawnPos)
def closeEvent(self, event):
labelConfig = (self.labelsView.selectedIndexes()[0].data(
role=Qt.DisplayRole), self.isOccludedButton.getEnabled(),
self.isTruncatedButton.getEnabled(),
self.isGroupOfButton.getEnabled(),
self.isDepictionButton.getEnabled(),
self.isInsideButton.getEnabled())
self.labelAccepted.emit(labelConfig)
super().closeEvent(event)
def getLabelConfig(self):
return
labelAccepted = Signal(object)
class Backend(QObject):
textChanged = Signal(str)
def __init__(self, parent=None):
QObject.__init__(self, parent)
self.m_text = ""
self.pictureModel = PictureModel()
self.keywordModel = QStringListModel()
self.selectedKeywordsModel = QStringListModel()
self.pictures = None
self.keywords = None
self.folders = []
@Property(str, notify=textChanged)
def text(self):
return self.m_text
@text.setter
def setText(self, text):
# We want to get notified even if it is the same thing... right?
#TODO need to handle duplicates somehow...
#if self.m_text == text:
# return
self.m_text = text
self.textChanged.emit(self.m_text)
def processFolder(self, folder):
folder = folder.strip("file:///") # Remove unnecessary bits
if folder not in self.folders: self.folders.append(folder)
#TODO get_all_pictures shouldn't overwrite what's in pictures, but add to it.
self.pictures = get_all_pictures(folder)
self.updateKeywordModel()
#TODO keywords model?
self.pictureModel.setPictureList(self.pictures)
def updateKeywordModel(self):
self.keywords = get_keywords(self.pictures)
print(self.keywords)
self.keywordModel.setStringList(self.keywords)
@Slot(int, result=str)
def getPicUrl(self, index):
return self.pictureModel.getPicturePath(index)
@Slot(result=int)
def numPics(self):
return self.pictureModel.rowCount(None)
@Slot(str)
def selectKeyword(self, keyword):
print("selecting keyword: " + str(keyword))
#Only do anything if the keyword is not already in the selected list
if keyword not in self.selectedKeywordsModel.stringList():
#Add keyword to selected list
self.selectedKeywordsModel.setStringList(
[*self.selectedKeywordsModel.stringList(), keyword])
self.filterKeywords()
def filterKeywords(self):
def f(x):
for keyword in self.selectedKeywordsModel.stringList():
if keyword in x[2]:
return True
return False
self.pictures = [*filter(f, self.pictures)]
self.pictureModel.setPictureList(self.pictures)
@Slot()
def clearPics(self):
#TODO is deleting the model really the best way to do this?
del self.pictureModel
self.pictureModel = PictureModel()
class Shell(QMainWindow):
def __init__(self): # constructor
super().__init__() # call the parent's constructor
# Test data in a model
self.users = ['User 1', 'User 2', 'User 3']
self.lv_model = QStringListModel()
self.lv_model.setStringList(self.users)
# Create the main window content widget
w = QWidget()
# Setup the rest of the main window appearance
self.setGeometry(300, 300, 640, 480)
self.setWindowTitle('PySide2 Listview Experiments')
self.setWindowIcon(QIcon('assets/icons/moon_64x64.png'))
# Create and set the main layout
layout = QVBoxLayout()
w.setLayout(layout) # Set the layout of the main window content widget
self.setCentralWidget(w)
# Create and add components to the layout
self.lv_label = QLabel('QListView with QStringListModel')
layout.addWidget(self.lv_label)
self.lv = QListView()
self.lv.setSelectionMode(
QListView.MultiSelection) # single selection is the default
self.lv.setModel(self.lv_model)
self.lv.selectionModel().selectionChanged.connect(self.item_selected)
layout.addWidget(self.lv)
self.button = QPushButton('Update model')
self.button.clicked.connect(self.change_model)
layout.addWidget(self.button)
self.selected_label = QLabel('Selected item: none')
layout.addWidget(self.selected_label)
layout.addStretch(1)
self.show() # display the UI
def change_model(self):
the_list = self.lv_model.stringList()
the_list.append('Another User')
self.lv_model.setStringList(the_list)
def item_selected(self):
# Get the current index (a QModelIndex object) from the QListView
# From the index, get the data (a QVariant) that you can convert to a QString
index = self.lv.currentIndex() # returns the primary QModelIndex
indices = self.lv.selectedIndexes() # returns a list of QModelIndex
selected_text = ''
for i in indices:
selected_text += i.data(
) + '\n' # use .data() to get the value from QModelIndex
self.selected_label.setText(selected_text)
class WordListDialog(QDialog):
"""Window to handle the edition of words in a word set"""
def __init__(self, parent=None):
super().__init__(parent)
self.setWindowTitle(self.tr("Edit Word set"))
self.setWindowIcon(QIcon(cm.DIR_ICONS + "app.png"))
box = QVBoxLayout()
self.add_button = QPushButton(self.tr("Add"))
self.add_file_button = QPushButton(self.tr("Add from file..."))
self.del_button = QPushButton(self.tr("Remove"))
self.del_button.setDisabled(True)
self.save_button = QPushButton(self.tr("Save"))
self.save_button.setDisabled(True)
self.cancel_button = QPushButton(self.tr("Cancel"))
box.addWidget(self.add_button)
box.addWidget(self.del_button)
box.addWidget(self.add_file_button)
box.addStretch()
box.addWidget(self.save_button)
box.addWidget(self.cancel_button)
self.view = QListView()
self.model = QStringListModel()
self.view.setModel(self.model)
self.view.setSelectionMode(QAbstractItemView.ExtendedSelection)
hlayout = QHBoxLayout()
hlayout.addWidget(self.view)
hlayout.addLayout(box)
self.setLayout(hlayout)
self.add_button.pressed.connect(self.on_add)
self.del_button.pressed.connect(self.on_remove)
self.add_file_button.pressed.connect(self.on_load_file)
self.cancel_button.pressed.connect(self.reject)
self.save_button.pressed.connect(self.accept)
# Item selected in view
self.view.selectionModel().selectionChanged.connect(
self.on_item_selected)
# Data changed in model
self.model.dataChanged.connect(self.on_data_changed)
self.model.rowsInserted.connect(self.on_data_changed)
self.model.rowsRemoved.connect(self.on_data_changed)
def on_item_selected(self, *args):
"""Enable the remove button when an item is selected"""
self.del_button.setEnabled(True)
def on_data_changed(self, *args):
"""Enable the save button when data in model is changed"""
self.save_button.setEnabled(True)
def on_add(self):
"""Allow to manually add a word to the list
Notes:
A user must click on save for the changes to take effect.
"""
data = self.model.stringList()
data.append(self.tr("<double click to edit>"))
self.model.setStringList(data)
def on_remove(self):
"""Remove the selected rows of the list
Notes:
A user must click on save for the changes to take effect.
"""
indexes = self.view.selectionModel().selectedRows()
while indexes:
self.model.removeRows(indexes[0].row(), 1)
indexes = self.view.selectionModel().selectedRows()
self.del_button.setDisabled(True)
def on_load_file(self):
"""Allow to automatically add words from a file
See Also:
:meth:`load_file`
"""
# Reload last directory used
last_directory = QSettings().value("last_directory", QDir.homePath())
filepath, _ = QFileDialog.getOpenFileName(self,
self.tr("Open Word set"),
last_directory,
self.tr("Text file (*.txt)"))
if filepath:
self.load_file(filepath)
def load_file(self, filename: str):
"""Load file into the view
Args:
filename(str): A simple file with a list of words (1 per line)
Current data filtering:
- Strip trailing spaces and EOL characters
- Skip empty lines
- Skip lines with whitespaces characters (`[ \t\n\r\f\v]`)
Examples:
- The following line will be skipped:
`"abc def\tghi\t \r\n"`
- The following line will be cleaned:
`"abc\r\n"`
"""
if not os.path.exists(filename):
return
# Sanitize words
with open(filename, "r") as f_h:
data = sanitize_words(f_h)
data.update(self.model.stringList())
self.model.setStringList(list(data))
# Simulate signal... TODO: check the syntax...
self.model.rowsInserted.emit(0, 0, 0)
class ControlMainWindow(QMainWindow):
def __init__(self, crypter):
super(ControlMainWindow, self).__init__(None)
self.icon = QSystemTrayIcon()
self.icon.setIcon(QtGui.QIcon('./eve_tray.png'))
self.icon.show()
self.setWindowIcon(QtGui.QIcon('./eve_tray.png'))
self.setWindowTitle('Pve Launcher')
self.ui = Ui_main_window()
self.ui.setupUi(self)
self.icon.activated.connect(self.activate)
self.account_list_model = QStringListModel()
self.ui.listView.setModel(self.account_list_model)
self.login_manager = EveLoginManager(crypter)
self.init_none_ui(crypter)
self.settings = None
self.load_settings()
self.ui.txt_client_path.setText(self.settings['eve_path'])
def init_none_ui(self, crypter):
self.login_manager.load()
acc_list = []
for account_name in self.login_manager.accounts:
acc_list.append(account_name)
self.account_list_model.setStringList(acc_list)
version_thread = Thread(target=self.check_eve_version)
version_thread.start()
def load_settings(self):
try:
with open('pvesettings.json', 'r') as settings_file:
self.settings = json.load(settings_file)
except FileNotFoundError:
self.settings = dict()
self.settings['eve_path'] = ""
def save_settings(self):
with open('pvesettings.json', 'w') as settings_file:
json.dump(self.settings, settings_file)
def closeEvent(self, event):
self.login_manager.save()
self.save_settings()
def changeEvent(self, event):
if event.type() == QEvent.WindowStateChange:
if self.windowState() & Qt.WindowMinimized:
self.icon.show()
QTimer.singleShot(0, self, SLOT('hide()'))
event.ignore()
def func_launch(self):
indexes = self.ui.listView.selectedIndexes()
# i get QModelIndex here
for idx in indexes:
try:
self.login_manager.login(idx.data(), self.get_auth_code,
self.get_charname,
self.ui.txt_client_path.text(),
self.ui.cbox_server.currentText())
except Exception as e:
logger.exception('Failed to launch')
invoke_in_main_thread(QMessageBox.critical, self, "Launch Error",
e.__str__(), QMessageBox.Ok)
def func_edit(self):
indexes = self.ui.listView.selectedIndexes()
# i get QModelIndex here
for idx in indexes:
account = self.login_manager.accounts[idx.data()]
dialog = AccountDialog("Edit Account", account.login_name,
account.plain_password(self.login_manager.coder),
account.direct_x, account.profile_name)
if dialog.show():
# result = [name, password, path, dx]:
path = dialog.result[2]
if not path.endswith(os.sep):
path = path + os.sep
account = EveAccount(dialog.result[0], dialog.result[1], self.login_manager.coder,
None, None, dialog.result[3], dialog.result[2])
self.login_manager.add_account(account)
def func_add(self):
dialog = AccountDialog("Create Account")
if dialog.show():
# [name, password, profile_name, dx]
account = EveAccount(dialog.result[0], dialog.result[1], self.login_manager.coder,
None, None, dialog.result[3], dialog.result[2])
self.login_manager.add_account(account)
acc_list = self.account_list_model.stringList()
acc_list.append(account.login_name)
self.account_list_model.setStringList(acc_list)
def func_delete(self):
indexes = self.ui.listView.selectedIndexes()
# i get QModelIndex here
model = self.ui.listView.model()
for idx in indexes:
self.login_manager.del_account(idx.data())
model.removeRow(idx.row())
def func_clear_cache(self):
self.login_manager.clear_cache()
def activate(self, reason):
if reason == QSystemTrayIcon.Trigger or reason == QSystemTrayIcon.DoubleClick:
self.showNormal()
self.raise_()
self.activateWindow()
# self.setWindowState(Qt.WindowNoState)
# self.activateWindow()
def func_browse_eve(self):
folder = QDir.toNativeSeparators(
QFileDialog.getExistingDirectory(None, "Eve Directory", "", QFileDialog.ShowDirsOnly))
if not folder.endswith(os.sep):
folder += os.sep
self.ui.txt_client_path.setText(folder)
self.settings['eve_path'] = folder
def check_eve_version(self):
headers = {'User-Agent': EveLoginManager.useragent}
#version_url = "http://client.eveonline.com/patches/premium_patchinfoTQ_inc.txt"
#req = request.Request(version_url, headers=headers)
#response = request.urlopen(req)
#version_data = response.read().decode('utf-8')
#match = re.match("BUILD:(\\d+)", version_data)
server_status = EveApi.get_server_status()
if server_status.version is None:
return None
version_string = str(server_status.version)
eve_version_okay: bool = check_eve_version(
version_string,
self.ui.txt_client_path.text())
if not eve_version_okay:
invoke_in_main_thread(QtWidgets.QMessageBox.information, self, "Eve Clients out of date",
"Your eve client is out of date.", QtWidgets.QMessageBox.Ok)
def set_server_status(self, text, number):
self.ui.label_server_status.setText(
QApplication.translate("main_window", text, None)
+ "({0:d})".format(number))
def get_auth_code(self, opener, request):
"""
:param opener: urllib.request.build_opener for sending an authcode per mail
:param request: request to send using the given opener
:return: the authcode
"""
inputDialog = QInputDialog(self)
inputDialog.setInputMode(QInputDialog.TextInput)
inputDialog.setCancelButtonText("Cancel")
inputDialog.setLabelText("Please enter your Authcode")
inputDialog.setWindowTitle("TwoFactorAuth")
inputDialog.setModal(True)
response = None
if inputDialog.exec_() == QInputDialog.Rejected: # send mail
return None, None
else:
return response, inputDialog.textValue().strip()
inputDialog.setCancelButtonText("Cancel")
if inputDialog.exec_() == QInputDialog.Rejected:
return response, None
return response, inputDialog.textValue().strip()
def get_charname(self):
"""
:param mailurl: url to call for sending an authcode per mail
:return: the authcode
"""
inputDialog = QInputDialog(self)
inputDialog.setInputMode(QInputDialog.TextInput)
inputDialog.setLabelText("Please enter a Charname")
inputDialog.setWindowTitle("Charname Challange")
inputDialog.setModal(True)
if inputDialog.exec_() == QInputDialog.Rejected:
return None
return inputDialog.textValue().strip()
class IntroPage(WizardPage):
UI_CLASS = Ui_Intro
TITLE = "Basic configuration"
SUBTITLE = "Please choose an application and other options to specify" " what you want to test."
FIELDS = {
"application": "app_combo",
"repository": "repository",
"bits": "bits_combo",
"arch": "arch_combo",
"build_type": "build_type",
"lang": "lang",
"url": "url",
}
def __init__(self):
WizardPage.__init__(self)
self.fetch_config = None
self.app_model = QStringListModel(
REGISTRY.names(lambda klass: not getattr(klass, "disable_in_gui", None))
)
self.ui.app_combo.setModel(self.app_model)
if mozinfo.bits == 64:
if mozinfo.os == "mac":
self.bits_model = QStringListModel(["64"])
bits_index = 0
else:
self.bits_model = QStringListModel(["32", "64"])
bits_index = 1
elif mozinfo.bits == 32:
self.bits_model = QStringListModel(["32"])
bits_index = 0
self.ui.bits_combo.setModel(self.bits_model)
self.ui.bits_combo.setCurrentIndex(bits_index)
self.arch_model = QStringListModel()
self.build_type_model = QStringListModel()
self.ui.app_combo.currentIndexChanged.connect(self._set_fetch_config)
self.ui.bits_combo.currentIndexChanged.connect(self._set_fetch_config)
self.ui.app_combo.setCurrentIndex(self.ui.app_combo.findText("firefox"))
self.ui.repository.textChanged.connect(self._on_repo_changed)
completer = QCompleter(sorted(get_branches()), self)
completer.setCaseSensitivity(Qt.CaseInsensitive)
self.ui.repository.setCompleter(completer)
QApplication.instance().focusChanged.connect(self._on_focus_changed)
def _on_repo_changed(self, text):
enable_release = not text or text == "mozilla-central"
build_select_page = self.wizard().page(2)
if type(build_select_page) == SingleBuildSelectionPage:
build_menus = [build_select_page.ui.build]
else:
build_menus = [build_select_page.ui.start, build_select_page.ui.end]
for menu in build_menus:
menu.ui.combo_helper.model().item(1).setEnabled(enable_release)
if menu.ui.combo_helper.currentIndex() == 1:
menu.ui.combo_helper.setCurrentIndex(0)
def _on_focus_changed(self, old, new):
# show the repository completion on focus
if new == self.ui.repository and not self.ui.repository.text():
self.ui.repository.completer().complete()
def _set_fetch_config(self, index):
app_name = str(self.ui.app_combo.currentText())
bits = int(self.ui.bits_combo.currentText())
self.fetch_config = create_config(app_name, mozinfo.os, bits, mozinfo.processor)
self.arch_model = QStringListModel(self.fetch_config.available_archs())
self.ui.arch_combo.setModel(self.arch_model)
if not self.arch_model.stringList():
self.ui.arch_label.setDisabled(True)
self.ui.arch_combo.setDisabled(True)
else:
self.ui.arch_label.setEnabled(True)
self.ui.arch_combo.setEnabled(True)
self.build_type_model = QStringListModel(self.fetch_config.available_build_types())
self.ui.build_type.setModel(self.build_type_model)
if not self.fetch_config.available_bits():
self.ui.bits_combo.setDisabled(True)
self.ui.label_4.setDisabled(True)
else:
self.ui.bits_combo.setEnabled(True)
self.ui.label_4.setEnabled(True)
# URL doesn't make sense for Thunderbird
if app_name == "thunderbird":
self.ui.url.setDisabled(True)
self.ui.url_label.setDisabled(True)
else:
self.ui.url.setEnabled(True)
self.ui.url_label.setEnabled(True)
# lang only makes sense for firefox-l10n, and repo doesn't
if app_name == "firefox-l10n":
self.ui.lang.setEnabled(True)
self.ui.lang_label.setEnabled(True)
self.ui.repository.setDisabled(True)
self.ui.repository_label.setDisabled(True)
else:
self.ui.lang.setDisabled(True)
self.ui.lang_label.setDisabled(True)
self.ui.repository.setEnabled(True)
self.ui.repository_label.setEnabled(True)
def validatePage(self):
app_name = self.fetch_config.app_name
launcher_class = LAUNCHER_REGISTRY.get(app_name)
try:
launcher_class.check_is_runnable()
return True
except LauncherNotRunnable as exc:
QMessageBox.critical(self, "%s is not runnable" % app_name, str(exc))
return False
