class TreeViewToolbar(QWidget):
# noinspection PyArgumentList
def __init__(self, scene, parent=None):
"""
The constructor for a tree view toolbar
:param scene: The tree scene for this toolbar
:param parent: The parent widget
"""
super(TreeViewToolbar, self).__init__(parent, Qt.Widget)
self.scene = scene
self.layout = QVBoxLayout(self)
self.zoom_in_button = view.elements.ToolbarButton(
QIcon("view/icon/plus.svg"))
self.zoom_in_button.setToolTip("Zoom In (Ctrl++)")
self.zoom_in_action = QAction()
self.zoom_in_action.setShortcuts(
[QKeySequence.ZoomIn,
QKeySequence(Qt.CTRL + Qt.Key_Equal)])
self.zoom_in_action.triggered.connect(self.zoom_in_button.animateClick)
self.zoom_in_button.addAction(self.zoom_in_action)
self.zoom_in_button.clicked.connect(
lambda: self.scene.zoom(1.25, 1.25))
self.zoom_out_button = view.elements.ToolbarButton(
QIcon("view/icon/minus.svg"))
self.zoom_out_button.setToolTip("Zoom Out (Ctrl+-)")
self.zoom_out_button.setShortcut(QKeySequence.ZoomOut)
self.zoom_out_button.clicked.connect(
lambda: self.scene.zoom(0.75, 0.75))
self.reset_button = view.elements.ToolbarButton(
QIcon("view/icon/refresh-cw.svg"))
self.reset_button.setToolTip("Reset View (F5)")
self.reset_action = QAction()
self.reset_action.setShortcuts(
[QKeySequence.Refresh,
QKeySequence(Qt.CTRL + Qt.Key_R)])
self.reset_action.triggered.connect(self.reset_button.animateClick)
self.reset_button.addAction(self.reset_action)
self.reset_button.clicked.connect(self.scene.align_tree)
self.layout.addWidget(self.zoom_in_button)
self.layout.addWidget(self.zoom_out_button)
self.layout.addWidget(self.reset_button)
self.setLayout(self.layout)
self.setGeometry(10, 10,
self.layout.sizeHint().width(),
self.layout.sizeHint().height())
def setupUi(self, MnStatusDlg):
MnStatusDlg.setModal(True)
layout = QVBoxLayout(MnStatusDlg)
layout.setContentsMargins(10, 15, 10, 10)
name = QLabel("<b><i>%s</i></b>" % self.mnAlias)
name.setAlignment(Qt.AlignCenter)
layout.addWidget(name)
body = QFormLayout()
body.setLabelAlignment(Qt.AlignRight)
body.setVerticalSpacing(20)
body.setContentsMargins(25, 10, 25, 30)
body.addRow(QLabel("<b>Address</b>"), QLabel(self.statusData['addr']))
body.addRow(QLabel("<b>Tx Hash: idx</b>"), QLabel(self.statusData['txhash']+": "+str(self.statusData['outidx'])))
body.addRow(QLabel("<b>Network</b>"), QLabel(self.statusData['network']))
body.addRow(QLabel("<b>Version</b>"), QLabel(str(self.statusData['version'])))
body.addRow(QLabel("<b>Rank</b>"), QLabel(str(self.statusData['rank'])))
body.addRow(QLabel("<b>Queue Position</b>"), QLabel(str(self.statusData['queue_pos'])))
body.addRow(QLabel("<b>Active Time</b>"), QLabel(sec_to_time(self.statusData['activetime'])))
body.addRow(QLabel("<b>Last Seen</b>"), QLabel(time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime(self.statusData['lastseen']))))
body.addRow(QLabel("<b>Last Paid</b>"), QLabel(time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime(self.statusData['lastpaid']))))
layout.addLayout(body)
self.okButton = QPushButton('OK')
self.okButton.clicked.connect(self.accept)
layout.addWidget(self.okButton)
sh = layout.sizeHint()
self.setFixedSize(sh)
def setupUi(self, PinMatrixDlg):
PinMatrixDlg.setModal(True)
layout = QVBoxLayout(PinMatrixDlg)
layout.setContentsMargins(10, 8, 10, 10)
# Header
title = QLabel("<b>%s</b>" % PinMatrixDlg.text)
title.setAlignment(Qt.AlignCenter)
layout.addWidget(title)
# Label
lbl_style = """
QLabel {margin-top: 10px; color: purple; font-size: 15pt}
"""
self.lbl_pin = QLabel()
self.lbl_pin.setAlignment(Qt.AlignCenter)
self.lbl_pin.setStyleSheet(lbl_style)
layout.addWidget(self.lbl_pin)
# Buttons
btn_style = """
QPushButton {padding: 1px 1px 1px; border: 1px solid purple; min-width: 90px; min-height:90px}
QPushButton:enabled {background-color: white}
QPushButton:pressed {background-color: purple; color:white; border: 1px solid purple}
"""
self.btn = []
for i in range(9):
btn_lab = '\u2022' if PinMatrixDlg.hideBtns else str(i + 1)
btn = QPushButton(btn_lab)
self.btn.append(btn)
# Grid
btnMatrix = QWidget(self)
btnMatrix.setStyleSheet(btn_style)
grid = QGridLayout()
grid.addWidget(self.btn[0], 2, 0, Qt.AlignCenter)
grid.addWidget(self.btn[1], 2, 1, Qt.AlignCenter)
grid.addWidget(self.btn[2], 2, 2, Qt.AlignCenter)
grid.addWidget(self.btn[3], 1, 0, Qt.AlignCenter)
grid.addWidget(self.btn[4], 1, 1, Qt.AlignCenter)
grid.addWidget(self.btn[5], 1, 2, Qt.AlignCenter)
grid.addWidget(self.btn[6], 0, 0, Qt.AlignCenter)
grid.addWidget(self.btn[7], 0, 1, Qt.AlignCenter)
grid.addWidget(self.btn[8], 0, 2, Qt.AlignCenter)
btnMatrix.setLayout(grid)
layout.addWidget(btnMatrix)
# Del/OK/Cancel button
self.btn_del = QPushButton('\u232b')
self.btn_del.setToolTip("Remove last entered key")
layout.addWidget(self.btn_del)
hBox = QHBoxLayout()
self.btn_ok = QPushButton('OK')
self.btn_cancel = QPushButton('Cancel')
hBox.addWidget(self.btn_ok)
hBox.addWidget(self.btn_cancel)
layout.addLayout(hBox)
sh = layout.sizeHint()
self.setFixedSize(sh)
def __init__(self,
label: str,
card: Card,
mw,
browser: Browser,
specific_info: str = None):
super().__init__()
self.mw = mw
self.card = card
hbox = QHBoxLayout()
hbox.addWidget(QLabel(label))
hbox.addStretch()
more_info = QLabel(specific_info)
hbox.addWidget(more_info)
card_btn = QPushButton("Card")
def show_card():
browser.form.searchEdit.lineEdit().setText("cid:" + str(card.id))
browser.onSearchActivated()
card_btn.clicked.connect(show_card)
forvo_btn = QPushButton("Forvo")
forvo_btn.clicked.connect(lambda: QDesktopServices.openUrl(
QUrl("https://forvo.com/search/" + label)))
hbox.addWidget(card_btn)
hbox.addWidget(forvo_btn)
hbox.setContentsMargins(10, 0, 0, 0)
vbox = QVBoxLayout()
vbox.addLayout(hbox)
vbox.setContentsMargins(0, 10, 10, 10)
self.setLayout(vbox)
self.setMinimumSize(vbox.sizeHint())
self.adjustSize()
class GenericDialog(QDialog):
def __init__(self, title: str, input_list: list[InputClass], entries_per_page: int=10, parent=None, message=None):
QDialog.__init__(self, parent)
self.setWindowTitle(title)
self.verticalLayout = QVBoxLayout(self)
self.tabWidget = QTabWidget(self)
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel | QDialogButtonBox.Ok)
self.buttonBox.accepted.connect(lambda: self.exit_dialog(True))
self.buttonBox.rejected.connect(lambda: self.exit_dialog(False))
self.input_list = input_list
current_page_number = 1
current_page = PageWidget(self)
if len(input_list) <= entries_per_page:
self.tabWidget.addTab(current_page, title)
else:
self.tabWidget.addTab(current_page, f'{title}: 1')
current_entry_number = 0
for input_obj in input_list:
current_entry_number += 1
if current_entry_number > entries_per_page:
current_page = PageWidget(self)
current_page_number += 1
self.tabWidget.addTab(current_page, f'{title}: {current_page_number}')
current_entry_number = 1
current_page.add_object(input_obj.get_label(), input_obj.get_widget())
if message:
messageLabel = QLabel()
messageLabel.setText(message)
messageLabel.setWordWrap(True)
self.verticalLayout.addWidget(messageLabel)
self.verticalLayout.addWidget(self.tabWidget)
self.verticalLayout.addWidget(self.buttonBox)
self.resize(self.verticalLayout.sizeHint())
self.output = None
self.accepted = False
self.setModal(True)
def exit_dialog(self, accepted):
self.accepted = accepted
self.close()
def closeEvent(self, event):
self.output = MixedDict()
for input_obj in self.input_list:
self.output[input_obj.get_label()] = input_obj.get_value()
class ImportModule(QDialog):
def __init__(self, parent=None):
super(ImportModule, self).__init__(parent)
self.layout = QVBoxLayout(self)
self.first_line = QHBoxLayout()
self.layout.addLayout(self.first_line)
self.first_line.addWidget(QLabel("Import module:"))
self.import_module_filename = QLineEdit()
self.first_line.addWidget(self.import_module_filename)
self.open_dialog_button = QPushButton(
self.style().standardIcon(QStyle.SP_DialogOpenButton), "")
self.first_line.addWidget(self.open_dialog_button)
self.second_line = QHBoxLayout()
self.layout.addLayout(self.second_line)
self.second_line.addWidget(QLabel("Module name:"))
self.module_name = QLineEdit()
self.second_line.addWidget(self.module_name)
self.buttons = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.buttons.button(QDialogButtonBox.Ok).clicked.connect(self.accept)
self.buttons.button(QDialogButtonBox.Cancel).clicked.connect(
self.reject)
self.layout.addWidget(self.buttons)
self.setFixedHeight(self.layout.sizeHint().height())
self.cfg = ConfigData()
self.setWindowTitle("Import module")
self.open_dialog_button.clicked.connect(self.open_dialog)
def open_dialog(self):
filename = QFileDialog.getOpenFileName(
self, "Select Module", self.cfg.last_opened_directory)[0]
if filename != "":
self.import_module_filename.setText(filename)
name, ext = os.path.splitext(os.path.basename(filename))
self.module_name.setText(name)
def filename(self):
return self.import_module_filename.text()
def name(self):
return self.module_name.text()
def done(self, code):
print(self.Accepted)
print(code)
if code != self.Accepted or os.path.exists(
self.import_module_filename.text()):
super(ImportModule, self).done(code)
else:
msg = QMessageBox(self)
msg.setText("Chosen file doesn't exist!")
msg.exec()
class eventWindow(QWidget):
def __init__(self,event):
super().__init__()
print(event)
self.vbox = QVBoxLayout()
self.eventData = QLabel()
self.eventData.setText('Id: {} Required access: {}'.format(
str(event['id']),event['required_access']
))
self.eventName = QLabel()
self.eventName.setText(event['name'])
self.eventDescription = QLabel()
self.eventDescription.setText(event['description'])
self.eventRequirement = QLabel()
self.eventRequirement.setText(event['requirement'])
self.eventRewards = QLabel()
self.eventRewards.setText('Rewards:')
self.vbox.addWidget(self.eventData)
self.vbox.addWidget(self.eventName)
self.vbox.addWidget(self.eventDescription)
self.vbox.addWidget(self.eventRequirement)
self.vbox.addWidget(self.eventRewards)
self.resize(self.vbox.sizeHint())
self.setLayout(self.vbox)
self.threads = []
for i in event['rewards']:
self.threads.append(loadThread(r'https://api.guildwars2.com/v2/items/' + str(i['id'])))
self.threads[-1].metaEventSignal.connect(self.addReward, Qt.QueuedConnection)
self.threads[-1].start()
def addReward(self, signal):
signal = json.loads(signal)
setattr(self,str(signal['id']),label(signal))
getattr(self, str(signal['id'])).setText(signal['name'])
getattr(self, str(signal['id'])).signal.connect(self.setItemWindow)
self.vbox.addWidget(getattr(self,str(signal['id'])))
self.resize(self.vbox.sizeHint())
def setItemWindow(self, signal):
self.itemWindow = itemWindow(signal)
self.itemWindow.show()
class MyApp(QMainWindow):
def __init__(self):
super().__init__()
self.add_btn = QPushButton("Add")
self.add_btn.clicked.connect(self.click_add_btn)
self.remove_btn = QPushButton("Remove")
self.remove_btn.clicked.connect(self.click_remove_btn)
self.scroll_area = QScrollArea()
self.scroll_area.setWidgetResizable(True)
self.init_ui()
def init_ui(self):
self.main_layout = QVBoxLayout()
self.main_layout.addWidget(self.add_btn)
self.main_layout.addWidget(self.remove_btn)
self.main_layout.addWidget(TestUI())
self.centralWidget = QWidget()
self.centralWidget.setLayout(self.main_layout)
self.setCentralWidget(self.centralWidget)
self.show()
def click_add_btn(self):
self.main_layout.addWidget(TestUI())
self.setFixedSize(
self.main_layout.sizeHint()
+ PyQt5.QtCore.QSize(0, TestUI().frameGeometry().height())
)
def click_remove_btn(self):
if self.main_layout.count() > 3:
child = self.main_layout.takeAt(self.main_layout.count() - 1)
child.widget().deleteLater()
print(self.main_layout.count())
print(self.main_layout.sizeHint())
self.setFixedSize(self.main_layout.sizeHint())
def __init__(self, graphicslist, parent=None):
super().__init__(parent)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.setWidgetResizable(True)
widget = QWidget(parent=self)
layout = QVBoxLayout(widget)
self.setWidget(widget)
self.setGraphics(graphicslist)
self.setMinimumWidth(layout.sizeHint().width() +
2 * self.frameWidth() +
self.verticalScrollBar().sizeHint().width())
class itemWindow(QWidget):
def __init__(self,item):
super().__init__()
self.vbox = QVBoxLayout()
self.itemId = QLabel()
self.itemId.setText(str(item['id']))
self.itemName = QLabel()
self.itemName.setText(item['name'])
self.vbox.addWidget(self.itemId)
self.vbox.addWidget(self.itemName)
self.resize(self.vbox.sizeHint())
self.setLayout(self.vbox)
def setupUi(self, PropDetailsDlg):
PropDetailsDlg.setModal(True)
layout = QVBoxLayout(PropDetailsDlg)
layout.setContentsMargins(10, 15, 10, 10)
name = QLabel("<b><i>%s</i></b>" % PropDetailsDlg.data.name)
name.setAlignment(Qt.AlignCenter)
layout.addWidget(name)
body = QFormLayout()
body.setLabelAlignment(Qt.AlignRight)
body.setVerticalSpacing(20)
body.setContentsMargins(25, 10, 25, 30)
link = "<a href='%s'>%s</a>" % (PropDetailsDlg.data.URL, PropDetailsDlg.data.URL)
link_label = QLabel(link)
link_label.setOpenExternalLinks(True)
body.addRow(QLabel("<b>URL: </b>"), link_label)
body.addRow(QLabel("<b>TotalPayment: </b>"), QLabel(str(PropDetailsDlg.data.ToalPayment)))
body.addRow(QLabel("<b>MonthlyPayment: </b>"), QLabel(str(PropDetailsDlg.data.MonthlyPayment)))
hashLabel = self.selectable_line(PropDetailsDlg.data.Hash)
body.addRow(QLabel("<b>Hash: </b>"), hashLabel)
feeHashLabel = self.selectable_line(PropDetailsDlg.data.FeeHash)
body.addRow(QLabel("<b>FeeHash: </b>"), feeHashLabel)
body.addRow(QLabel("<b>BlockStart: </b>"), QLabel(str(PropDetailsDlg.data.BlockStart)))
body.addRow(QLabel("<b>BlockEnd: </b>"), QLabel(str(PropDetailsDlg.data.BlockEnd)))
body.addRow(QLabel("<b>TotalPayCount: </b>"), QLabel(str(PropDetailsDlg.data.TotalPayCount)))
body.addRow(QLabel("<b>RemainingPayCount: </b>"), QLabel(str(PropDetailsDlg.data.RemainingPayCount)))
addyLabel = self.selectable_line(PropDetailsDlg.data.PaymentAddress)
body.addRow(QLabel("<b>PaymentAddress: </b>"), addyLabel)
votes = "<span style='color: green'>%d YEAS</span> / " % PropDetailsDlg.data.Yeas
votes += "<span style='color: orange'>%d ABSTAINS</span> / " % PropDetailsDlg.data.Abstains
votes += "<span style='color: red'>%d NAYS</span>" % PropDetailsDlg.data.Nays
body.addRow(QLabel("<b>Votes: </b>"), QLabel(votes))
my_yeas = ["%s <em style='color: green'>(%s)</em>" % (x[0], strftime('%Y-%m-%d %H:%M:%S',
gmtime(x[1]))) for x in PropDetailsDlg.myYeas]
body.addRow(QLabel("<b>My Yeas: </b>"), self.scroll(my_yeas))
my_abstains = ["%s <em style='color: orange'>(%s)</em>" % (x[0], strftime('%Y-%m-%d %H:%M:%S',
gmtime(x[1]))) for x in PropDetailsDlg.myAbstains]
body.addRow(QLabel("<b>My Abstains: </b>"), self.scroll(my_abstains))
my_nays = ["%s <em style='color: red'>(%s)</em>" % (x[0], strftime('%Y-%m-%d %H:%M:%S',
gmtime(x[1]))) for x in PropDetailsDlg.myNays]
body.addRow(QLabel("<b>My Nays: </b>"), self.scroll(my_nays))
layout.addLayout(body)
self.okButton = QPushButton('OK')
self.okButton.clicked.connect(self.accept)
layout.addWidget(self.okButton)
sh = layout.sizeHint()
self.setFixedSize(sh)
class Ui(QFrame):
flags = Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint
settings = None
header = None
body = None
mouse_down = False
old_position = None
header_layout = None
column_layout = None
events_layout = None
token_path = path.join(APPDATA, 'token.json')
credentials = None
service = None
calendars = []
events = []
icons = {}
def __init__(self):
super(Ui, self).__init__(None, self.flags)
self.authorize()
self.settings = QSettings(NAME, NAME)
geometry = self.settings.value('geometry')
if geometry:
self.restoreGeometry(geometry)
self.setFrameShape(QFrame.StyledPanel)
# TODO: QPushButton[iconOnly="True"] should be circle button
css = """
QFrame {
background-color: white;
border: 1px solid #3949AB;
}
QPushButton {
background-color: #3949AB;
color: white;
border-radius: 5px;
padding: 10px 20px;
min-width: 50px;
}
QPushButton[iconOnly="True"] {
padding: 10px;
min-width: unset;
}
QPushButton:hover {
background-color: #5C6BC0;
}
"""
self.setStyleSheet(css)
self.setMouseTracking(True)
self.header = Header(self)
self.body = QWidget(self)
css = """
QWidget {
border: 0;
}
QWidget[class~="event"] {
background-color: #7986CB;
border-radius: 5px;
}
QWidget[class~="event"] QLabel {
background-color: #7986CB;
color: white;
}
QWidget[class~="needsAction"] {
border-top: 5px Solid #304FFE;
border-top-left-radius: 0;
border-top-right-radius: 0;
}
QWidget[class~="event"] QLabelClickable {
color: #3949AB;
font-weight: bold;
text-decoration: underline;
}
QProgressBar {
background-color: #7986CB;
}
"""
self.body.setStyleSheet(css)
self.header_layout = QVBoxLayout(self)
self.header_layout.setSizeConstraint(QLayout.SetFixedSize)
self.header_layout.setContentsMargins(0, 0, 0, 0)
self.header_layout.setSpacing(0)
self.header_layout.addWidget(self.header)
body_layout = QVBoxLayout()
body_layout.addWidget(self.body)
body_layout.setContentsMargins(5, 5, 5, 5)
body_layout.setSpacing(0)
self.header_layout.addLayout(body_layout)
self.setup_ui()
def closeEvent(self, event):
self.settings.setValue('geometry', self.saveGeometry())
def mousePressEvent(self, event):
self.old_position = event.pos()
self.mouse_down = event.button() == Qt.LeftButton
def mouseReleaseEvent(self, event):
self.mouse_down = False
def authorize(self):
if os.path.exists(self.token_path):
self.credentials = Credentials.from_authorized_user_file(
self.token_path, SCOPES)
if not self.credentials or not self.credentials.valid:
if self.credentials and self.credentials.expired and self.credentials.refresh_token:
try:
self.credentials.refresh(Request())
except RefreshError:
os.remove(self.token_path)
self.credentials = None
return self.authorize()
else:
flow = InstalledAppFlow.from_client_secrets_file(
'credentials.json', SCOPES)
self.credentials = flow.run_local_server(port=0)
with open(self.token_path, 'w') as token:
token.write(self.credentials.to_json())
self.service = build('calendar', 'v3', credentials=self.credentials)
def logout(self):
if os.path.exists(self.token_path):
os.remove(self.token_path)
self.credentials = None
self.authorize()
self.refresh()
# TODO: Make events layout scrollable
def setup_ui(self):
self.column_layout = QVBoxLayout(self.body)
self.column_layout.setSpacing(15)
menu_layout = QHBoxLayout()
self.column_layout.addLayout(menu_layout)
self.events_layout = QVBoxLayout()
self.events_layout.setSpacing(15)
self.column_layout.addLayout(self.events_layout)
logout_button = QPushButton('Logout')
logout_button.clicked.connect(self.logout)
menu_layout.addWidget(logout_button)
refresh_button = QPushButton('Refresh')
refresh_button.clicked.connect(self.refresh)
menu_layout.addWidget(refresh_button)
QMetaObject.connectSlotsByName(self)
self.refresh()
# TODO: Subscribe to changes or poll each 15m
# TODO: Store when the last refresh happened to prevent unnecessary refresh when event end and send a refresh
def refresh(self):
self.calendars = []
self.paged_query(self.refresh_calendars)
self.events = []
now = datetime.datetime.utcnow(
) # TODO: Do we need to use a specific timezone?
time_min = now.isoformat() + 'Z'
time_max = now.replace(
hour=23, minute=59, second=59,
microsecond=999999).isoformat() + 'Z'
for calendar in self.calendars:
self.paged_query(self.refresh_events, calendar, time_min, time_max)
clear_layout(self.events_layout)
for event in self.events:
if 'dateTime' in event['start'] and 'dateTime' in event['end']:
self.events_layout.addWidget(Event(self, event))
self.refresh_size()
def refresh_size(self):
size = self.header_layout.sizeHint()
available_size = self.screen().availableSize()
size.setWidth(min(size.width(), available_size.width()))
size.setHeight(min(size.height(), available_size.height()))
self.setFixedSize(size)
# TODO: If fail to fetch an uri for X times, find a way to limit future try or stop trying
# TODO: Store & restore on drive
def fetch_icon(self, uri):
if uri in self.icons:
return self.icons[uri]
else:
try:
data = urlopen(uri).read(
) # TODO: Investigate on .read() raised exceptions
except (URLError, HTTPError, ContentTooShortError) as exception:
handle_error(exception)
return None
pixmap = QPixmap()
pixmap.loadFromData(data)
icon = QIcon(pixmap)
self.icons[uri] = icon
return icon
@staticmethod
def paged_query(func, *args, **kwargs):
page_token = None
while True:
page_token = func(page_token, *args, **kwargs)
if not page_token:
break
def refresh_events(self, page_token, calendar, time_min, time_max):
events = self.service.events().list(calendarId=calendar['id'],
singleEvents=True,
timeMin=time_min,
timeMax=time_max,
orderBy='startTime',
pageToken=page_token,
maxAttendees=1,
showDeleted=False).execute()
def remove_declined_event(event):
if 'attendees' in event and event['attendees'][0]:
if event['attendees'][0]['responseStatus'] == 'declined':
return False
return True
self.events += filter(remove_declined_event, events['items'])
return events.get('nextPageToken')
# TODO: Let user choose which calendar the want to fetch events from
def refresh_calendars(self, page_token):
calendar_list = self.service.calendarList().list(
pageToken=page_token, minAccessRole='owner').execute()
self.calendars += calendar_list['items']
return calendar_list.get('nextPageToken')
def setUI(self):
self.window = QWidget()
self.window.setWindowIcon(QtGui.QIcon(dir_path + 'resources/bbp.png'))
self.window.setWindowTitle('vocabBuilder')
self.btn_exit = QPushButton('Exit')
self.btn_exit.clicked.connect(self.exitClicked)
self.btn_start = QPushButton('Start')
self.btn_start.clicked.connect(self.startClicked)
# The start button should be initially disabled if no file exists
if self.fileName == '':
self.btn_start.setEnabled(False)
# Check the file still exists and is valid
else:
self.btn_start.setEnabled(self.checkFileContents(self.fileName))
self.btn_words = QPushButton('Words')
self.btn_words.clicked.connect(self.wordsClicked)
self.spin_time = QSpinBox()
self.spin_time.setMinimum(1)
self.spin_time.setValue(self.time)
self.spin_questions = QSpinBox()
self.spin_questions.setMinimum(1)
self.spin_questions.setValue(self.questions)
wordsLabel = QLabel('Questions:')
timeLabel = QLabel('Time:')
picLabel = QLabel()
pixmap = QPixmap(dir_path + 'resources/bbp.png')
picLabel.setPixmap(pixmap)
mainLayout = QVBoxLayout(self.window)
leftLayout = QVBoxLayout()
leftLayout.addWidget(picLabel)
vSpacer = QSpacerItem(5, 10, QSizePolicy.Minimum,
QSizePolicy.Expanding)
hSpacer = QSpacerItem(10, 5, QSizePolicy.Minimum,
QSizePolicy.Expanding)
rightLayout = QVBoxLayout()
rightLayout.setSpacing(0)
rightLayout.setContentsMargins(0, 0, 0, 0)
rightLayout.addWidget(timeLabel)
rightLayout.addWidget(self.spin_time)
rightLayout.addWidget(wordsLabel)
rightLayout.addWidget(self.spin_questions)
rightLayout.addItem(vSpacer)
bottomLayout = QHBoxLayout()
bottomLayout.addWidget(self.btn_words)
bottomLayout.addWidget(self.btn_start)
bottomLayout.addWidget(self.btn_exit)
topLayout = QHBoxLayout()
topLayout.addLayout(leftLayout)
topLayout.addLayout(rightLayout)
mainLayout.addLayout(topLayout)
mainLayout.addLayout(bottomLayout)
self.window.setFixedSize(mainLayout.sizeHint())
return
def setupUi(self, dlg):
Ui_Dialog.setupUi(self, dlg)
self.btnShowHist.clicked.connect(self.showHistogram)
self._filterListOrderMapper = FilterListOrderMapper()
self._filterListOrderMapper.listChanged.connect(
self.resetFilterListModel)
self.filterList.installEventFilter(self._filterListOrderMapper)
self.filterList.setDragDropMode(QAbstractItemView.InternalMove)
self._optionMapper = QSignalMapper(dlg)
self._optionMapper.mapped[QObject].connect(self.saveFilterValue)
self._optionSave = [
] # this is only for making sure the Mapper object doesn't get garbage collected
#regx = QRegExp( "([0-9]{1,3}[\,][ ]*){2}[0-9]{1,3}" )
regx = QRegExp("([0-9]{1,3}[\,][ ]*){1,2}[0-9]{1,3}")
for fltr in self._filters:
print("Filter added: %s" % fltr.name)
fltr.loadConfig(None)
self.label_Status.setText("Loading filters")
getters, setters = self.getFilterProperties(fltr)
print("\tAvailable GETable options: ", getters)
print("\tAvailable SETable options: ", setters)
group = QGroupBox()
vbl = QVBoxLayout(group)
# Row ------
fm = QFrame()
vb = QVBoxLayout(fm)
vb.setSizeConstraint(QLayout.SetFixedSize)
# add the enabled checkbox first always
cb2 = QCheckBox(fltr.name)
cb2.setCheckState(
getattr(
fltr, FrameProcessor.propStartsWith + "Enabled" +
FrameProcessor.propEndsWithGetter)())
cb2.setStyleSheet('background-color:#%02x%02x%02x' %
(fltr.color()[::-1]))
vb.addWidget(cb2)
# watch for values changing
cb2.stateChanged.connect(self._optionMapper.map)
self._optionSave.append(
KnobTurner.Mapper(
cb2, fltr, FrameProcessor.propStartsWith + "Enabled" +
FrameProcessor.propEndsWithSetter))
self._optionMapper.setMapping(cb2, self._optionSave[-1])
for item in setters:
prop_type = getattr(fltr,
FrameProcessor.propTypeStartsWith + item)()
if prop_type is int:
hz = QHBoxLayout()
lb1 = QLabel("%s:" % item)
sp1 = QSpinBox()
sp1.setRange(
0, 10000000) # TODO: add this as a query to the filter
sp1.setValue(
getattr(
fltr, FrameProcessor.propStartsWith + item +
FrameProcessor.propEndsWithGetter)())
vb.addWidget(lb1)
vb.addWidget(sp1)
# watch for values changing
sp1.valueChanged.connect(self._optionMapper.map)
self._optionSave.append(
KnobTurner.Mapper(
sp1, fltr, FrameProcessor.propStartsWith + item +
FrameProcessor.propEndsWithSetter))
self._optionMapper.setMapping(sp1, self._optionSave[-1])
elif prop_type is bool:
if item == "Enabled":
continue
else:
cb2 = QCheckBox(item)
cb2.setCheckState(
getattr(
fltr, FrameProcessor.propStartsWith + item +
FrameProcessor.propEndsWithGetter)())
vb.addWidget(cb2)
# watch for values changing
cb2.stateChanged.connect(self._optionMapper.map)
self._optionSave.append(
KnobTurner.Mapper(
cb2, fltr, FrameProcessor.propStartsWith + item +
FrameProcessor.propEndsWithSetter))
self._optionMapper.setMapping(cb2, self._optionSave[-1])
elif prop_type is tuple:
hz = QHBoxLayout()
lb1 = QLabel("%s:" % item)
val = getattr(
fltr, FrameProcessor.propStartsWith + item +
FrameProcessor.propEndsWithGetter)()
le = QLineEdit("{0}".format(val).replace("(", "").replace(
")", "").replace("[", "").replace("]", ""))
le.setValidator(QRegExpValidator(regx))
le.textChanged.connect(self._optionMapper.map)
le.textChanged.emit(le.text())
self._optionSave.append(
KnobTurner.Mapper(
le, fltr, FrameProcessor.propStartsWith + item +
FrameProcessor.propEndsWithSetter))
self._optionMapper.setMapping(le, self._optionSave[-1])
vb.addWidget(lb1)
vb.addWidget(le)
# end Row 2 -----
vbl.addWidget(fm)
vbl.setSizeConstraint(QLayout.SetFixedSize)
lwi = QListWidgetItem()
lwi.setSizeHint(vbl.sizeHint())
lwi.setData(
Qt.UserRole,
QVariant(fltr)) # attach the filter to this item in the list
self.filterList.addItem(lwi)
self.filterList.setItemWidget(lwi, group)
self.label_Status.setText("Loading filters... Done")
self.label_Status.setText("Starting cameras...")
self.startCamera()
self.label_Status.setText("Starting cameras... Done")
self.showWindows()
self.label_Status.setText("Ready")
class Window(QWidget):
def __init__(self):
super(Window, self).__init__()
self.icon_path = 'resources\\warframe.ico'
self.app_title = 'Warframe Prime Helper'
self.company_name = 'Warframe Tools'
self.settings = QSettings(self.company_name, self.app_title)
self.setWindowTitle(self.app_title)
self.market_api = None
self.image_label = None
self.image_label2 = None
self.warframe_height = 1080
self.warframe_width = 1920
self.table = None
self.mission_table = None
self.slider_names = None
self.sliders = None
self.slider_labels = None
self.slider_default_values = None
self.slider_orig_values = None
self.slider_values = None
self.is_slider_max_set = False
#self.plat_check_box = QCheckBox("Prefer platinum")
#self.plat_check_box.setChecked(True)
self.update_prices_button = None
self.update_ducats_button = None
self.update_prices_progress = None
self.update_ducats_progress = None
self.last_updated_prices_value = None
self.last_updated_ducats_value = None
self.num_parts_value = None
self.latest_item_value = None
self.move_to_top_check_box = None
self.pause_button = None
self.is_paused = False
self.hide_crop_check_box = None
self.hide_filter_check_box = None
self.hide_fissure_check_box = None
self.relics = None
self.hide_relics = {}
self.hidden_relics = set()
self.hide_missions = {}
self.hidden_missions = set()
self.hide_missions_box = None
self.mission_names = None
self.crop_img = None
self.filter_img = None
self.dialog = None
self.layout = None
self.filled_rows = 0
self.max = -1
self.max_row = -1
self.ocr = None
self.old_screenshot_shape = 0
self.old_filtered_shape = 0
self.missions = []
self.num_primes = 100
self.api = None
self.prices_progress_lock = Lock()
self.ducats_progress_lock = Lock()
self.ducats_thread = None
self.prices_thread = None
self.timer = None
self.init_image_labels()
self.init_tables()
self.init_sliders()
self.init_dialog()
self.set_layout()
self.init_timer()
self.show()
#measured correct values
self.setFixedSize(978, 617)
def init_timer(self):
self.timer = QTimer()
self.timer.timeout.connect(self.update_mission_table_time)
self.timer.start(1000)
def init_image_labels(self):
self.image_label = QLabel()
image = QPixmap('temp\\crop_27.bmp')
self.image_label.setPixmap(image)
self.image_label2 = QLabel()
self.image_label2.setPixmap(image)
def set_layout(self):
settings_button_box = self.make_settings_button_box()
self.init_imgs()
bot_box = self.make_bot_box()
self.layout = QVBoxLayout()
self.layout.setAlignment(Qt.AlignTop)
self.layout.addSpacing(-12)
self.layout.addLayout(settings_button_box)
self.layout.addWidget(self.crop_img)
self.layout.addWidget(self.filter_img)
self.layout.addWidget(bot_box)
self.setLayout(self.layout)
def make_settings_button_box(self):
settings_button = QPushButton()
# Gear icon is from: https://iconscout.com/icon/gear-222
style_sheet = """
QPushButton {
qproperty-icon: url(" ");
qproperty-iconSize: 15px 15px;
border-image: url("resources/Gear.svg");
background-color: rgba(255, 255, 255, 0);
}
QPushButton:hover {
border-image: url("resources/SelectedGear.svg");
}"""
settings_button.setStyleSheet(style_sheet)
#settings_button.setStyleSheet("background-color: rgba(0, 0, 0, 255); font-size: 23px;")
settings_button.clicked.connect(self.show_preferences)
settings_button.setFixedWidth(30)
settings_button.setFixedHeight(30)
settings_button_hb = QHBoxLayout()
settings_button_hb.setAlignment(Qt.AlignRight)
settings_button_hb.addWidget(settings_button)
settings_button_hb.addSpacing(-11)
return settings_button_hb
def make_bot_box(self):
bot_layout = QHBoxLayout()
bot_layout.addWidget(self.table)
bot_layout.addWidget(self.mission_table)
bot_box = QGroupBox()
bot_box.setLayout(bot_layout)
bot_box.setFixedHeight(287)
return bot_box
def init_dialog(self):
crop_box = self.make_crop_box()
filter_box = self.make_filter_box()
other_box = self.make_other_box()
settings_layout_1 = QVBoxLayout()
settings_layout_1.addWidget(crop_box)
settings_layout_1.addWidget(filter_box)
settings_layout_1.addWidget(other_box)
update_box = self.make_update_box()
rate_box = self.make_rate_box()
settings_layout_2 = QVBoxLayout()
settings_layout_2.addWidget(update_box)
settings_layout_2.addWidget(rate_box)
hide_box = self.make_hide_box()
hide_relics_box = self.make_hide_relics_box()
button_box = self.make_button_box()
settings_layout_3 = QVBoxLayout()
settings_layout_3.addWidget(hide_box)
settings_layout_3.addWidget(hide_relics_box)
hide_missions_box = self.make_hide_missions_box()
settings_layout_4 = QVBoxLayout()
settings_layout_4.addWidget(hide_missions_box)
settings_layout_4.addWidget(button_box)
settings_layout = QHBoxLayout()
settings_layout.addLayout(settings_layout_1)
settings_layout.addLayout(settings_layout_2)
settings_layout.addLayout(settings_layout_3)
settings_layout.addLayout(settings_layout_4)
self.dialog = QDialog()
self.dialog.setWindowTitle("Preferences")
self.dialog.setWindowModality(Qt.ApplicationModal)
self.dialog.setLayout(settings_layout)
def make_button_box(self):
button_box = QDialogButtonBox()
button_box.setOrientation(Qt.Horizontal)
button_box.setStandardButtons(QDialogButtonBox.Cancel | QDialogButtonBox.Ok)
button_box.accepted.connect(self.save_settings)
button_box.rejected.connect(self.load_settings)
return button_box
def load_settings(self):
self.settings.sync()
slider_orig_values = {'x': 521, 'y': 400, 'w': 908, 'h': 70, 'v1': 197, 'v2': 180, 'd': 4,
'Screencap (hz)': 1, 'Fissure (s)': 30, 'API Threads': 4}
self.slider_default_values = {}
slider_default_max = {'x': self.warframe_width/2,
'y': self.warframe_height/2,
'w': self.warframe_width,
'h': self.warframe_height,
'v1': 255,
'v2': 255,
'd': 40}
for slider_name in self.slider_names:
self.slider_default_values[slider_name] = self.settings.value(slider_name,defaultValue=slider_orig_values[slider_name])
if len(slider_name) <= 2:
max_val = self.settings.value("{}_max".format(slider_name), defaultValue=slider_default_max[slider_name], type=int)
self.sliders[slider_name].setMaximum(max_val)
self.sliders[slider_name].setValue(self.slider_default_values[slider_name])
prices = self.settings.value("last_updated_prices_value", defaultValue="Never", type=str)
ducats = self.settings.value("last_updated_ducats_value", defaultValue="Never", type=str)
num_parts = self.settings.value("num_parts_value", defaultValue=350, type=int)
latest_item = self.settings.value("latest_item_value", defaultValue="", type=str)
self.last_updated_prices_value.setText(prices)
self.last_updated_ducats_value.setText(ducats)
self.num_parts_value.setNum(num_parts)
self.latest_item_value.setText(latest_item)
for relic in self.relics:
checked = self.settings.value("hide_{}".format(relic), defaultValue=False,type=bool)
self.hide_relics[relic].setChecked(checked)
if checked:
self.set_hidden_relic(relic)
for mission in self.mission_names:
checked = self.settings.value("hide_{}".format(mission), defaultValue=False, type=bool)
self.hide_missions[mission].setChecked(checked)
if checked:
self.set_hidden_mission(mission)
if self.settings.value("toggle_fissure_table", defaultValue=False, type=bool):
self.hide_fissure_check_box.setChecked(True)
self.toggle_fissure_table()
if self.settings.value("toggle_move_to_top", defaultValue=False, type=bool):
self.move_to_top_check_box.setChecked(True)
self.toggle_move_to_top()
if self.settings.value("toggle_cropped_img", defaultValue=False, type=bool):
self.hide_crop_check_box.setChecked(True)
self.toggle_cropped_img()
if self.settings.value("toggle_filtered_img", defaultValue=False, type=bool):
self.hide_filter_check_box.setChecked(True)
self.toggle_filtered_img()
self.dialog.close()
def save_settings(self):
for slider_name in self.slider_names:
self.settings.setValue(slider_name, self.sliders[slider_name].value())
for relic in self.relics:
self.settings.setValue("hide_{}".format(relic), self.hide_relics[relic].isChecked())
for mission in self.mission_names:
self.settings.setValue("hide_{}".format(mission), self.hide_missions[mission].isChecked())
self.settings.setValue("toggle_fissure_table", self.hide_fissure_check_box.isChecked())
self.settings.setValue("toggle_move_to_top", self.move_to_top_check_box.isChecked())
self.settings.setValue("toggle_cropped_img", self.hide_crop_check_box.isChecked())
self.settings.setValue("toggle_filtered_img", self.hide_filter_check_box.isChecked())
self.dialog.close()
self.settings.sync()
def init_imgs(self):
self.crop_img = QGroupBox("Crop")
crop_img_layout = QVBoxLayout()
crop_img_layout.addWidget(self.image_label)
self.crop_img.setLayout(crop_img_layout)
self.filter_img = QGroupBox("Filtered")
filter_img_layout = QVBoxLayout()
filter_img_layout.addWidget(self.image_label2)
self.filter_img.setLayout(filter_img_layout)
def make_hide_missions_box(self, missions=None):
if self.hide_missions_box is None:
self.hide_missions_box = QGroupBox("Hide Missions")
if missions is not None:
hide_missions_layout = QGridLayout()
hide_missions_layout.setColumnStretch(2, 2)
hide_missions_layout.setAlignment(Qt.AlignTop)
hide_missions_layout.setContentsMargins(0, 0, 0, 0)
skip_missions = ["MT_SECTOR", "MT_PVP", "MT_LANDSCAPE", "MT_EVACUATION", "MT_ASSASSINATION", "MT_ARENA"]
seen_missions = set()
i = 0
for mission in missions:
mission_name = missions[mission]['value']
if mission_name == "Extermination":
mission_name = "Exterminate"
if mission not in skip_missions and mission_name not in seen_missions:
self.hide_missions[mission_name] = QCheckBox(mission_name)
self.hide_missions[mission_name].setChecked(False)
self.hide_missions[mission_name].stateChanged.connect(partial(self.set_hidden_mission, mission_name))
hide_missions_layout.addWidget(self.hide_missions[mission_name], int(i/2), i % 2)
i += 1
seen_missions.add(mission_name)
self.hide_missions_box.setLayout(hide_missions_layout)
self.mission_names = list(seen_missions)
self.load_settings()
return self.hide_missions_box
def set_hidden_mission(self, mission):
if self.hide_missions[mission].isChecked():
self.hidden_missions.add(mission)
else:
self.hidden_missions.remove(mission)
self.update_mission_table_hidden()
def make_hide_relics_box(self):
hide_relics_layout = QVBoxLayout()
hide_relics_layout.setAlignment(Qt.AlignTop)
hide_relics_layout.setContentsMargins(0, 0, 0, 0)
self.relics = ["Axi", "Neo", "Meso", "Lith", "Requiem"]
for relic in self.relics:
self.hide_relics[relic] = QCheckBox(relic)
self.hide_relics[relic].setChecked(False)
self.hide_relics[relic].stateChanged.connect(partial(self.set_hidden_relic, relic))
hide_relics_layout.addWidget(self.hide_relics[relic])
hide_relics_box = QGroupBox("Hide Relics")
hide_relics_box.setLayout(hide_relics_layout)
return hide_relics_box
def make_hide_box(self):
hide_layout = QVBoxLayout()
hide_layout.setAlignment(Qt.AlignTop)
hide_layout.setContentsMargins(0, 0, 0, 0)
self.hide_crop_check_box = QCheckBox("Hide Crop")
self.hide_crop_check_box.setChecked(False)
self.hide_crop_check_box.stateChanged.connect(self.toggle_cropped_img)
hide_layout.addWidget(self.hide_crop_check_box)
self.hide_filter_check_box = QCheckBox("Hide Filtered")
self.hide_filter_check_box.setChecked(False)
self.hide_filter_check_box.stateChanged.connect(self.toggle_filtered_img)
hide_layout.addWidget(self.hide_filter_check_box)
self.hide_fissure_check_box = QCheckBox("Hide Fissure Table")
self.hide_fissure_check_box.setChecked(False)
self.hide_fissure_check_box.stateChanged.connect(self.toggle_fissure_table)
hide_layout.addWidget(self.hide_fissure_check_box)
hide_box = QGroupBox("Hide UI")
hide_box.setLayout(hide_layout)
return hide_box
def make_rate_box(self):
rate_grid = QGridLayout()
rate_grid.setColumnStretch(3, 3)
rate_grid.setContentsMargins(0, 0, 0, 0)
for i in range(3):
slider_name = self.slider_names[i + 7]
rate_grid.addWidget(self.slider_labels[slider_name], i, 0)
rate_grid.addWidget(self.slider_values[slider_name], i, 1)
rate_grid.addWidget(self.sliders[slider_name], i, 2)
rate_box = QGroupBox("Rates")
rate_box.setLayout(rate_grid)
return rate_box
def make_other_box(self):
self.move_to_top_check_box = QCheckBox("Bring to front")
self.move_to_top_check_box.setChecked(True)
self.move_to_top_check_box.stateChanged.connect(self.toggle_move_to_top)
self.pause_button = QPushButton("Pause")
self.pause_button.clicked.connect(self.toggle_button)
self.is_paused = False
other_layout = QVBoxLayout()
other_layout.setAlignment(Qt.AlignTop)
other_layout.setContentsMargins(0, 0, 0, 0)
other_layout.addWidget(self.move_to_top_check_box)
other_layout.addWidget(self.pause_button)
other_box = QGroupBox("Other")
other_box.setLayout(other_layout)
return other_box
def make_filter_box(self):
filter_grid = QGridLayout()
filter_grid.setColumnStretch(3, 3)
filter_grid.setAlignment(Qt.AlignTop)
filter_grid.setContentsMargins(0, 0, 0, 0)
for i in range(3):
slider_name = self.slider_names[i + 4]
filter_grid.addWidget(self.slider_labels[slider_name], i, 0)
filter_grid.addWidget(self.slider_values[slider_name], i, 1)
filter_grid.addWidget(self.sliders[slider_name], i, 2)
filter_box = QGroupBox("Filter Parameters")
filter_box.setLayout(filter_grid)
return filter_box
def make_crop_box(self):
crop_grid = QGridLayout()
crop_grid.setColumnStretch(3, 4)
crop_grid.setAlignment(Qt.AlignTop)
crop_grid.setContentsMargins(0, 0, 0, 0)
for i in range(4):
slider_name = self.slider_names[i]
crop_grid.addWidget(self.slider_labels[slider_name], i, 0)
crop_grid.addWidget(self.slider_values[slider_name], i, 1)
crop_grid.addWidget(self.sliders[slider_name], i, 2)
crop_box = QGroupBox("Crop Parameters")
crop_box.setLayout(crop_grid)
return crop_box
def make_update_box(self):
update_layout = QGridLayout()
update_layout.setColumnStretch(4, 2)
update_layout.setAlignment(Qt.AlignTop)
update_layout.setContentsMargins(0, 0, 0, 0)
self.update_prices_button = QPushButton("Update Prices")
self.update_prices_button.clicked.connect(self.update_prices)
self.update_prices_progress = QProgressBar()
self.update_prices_progress.setFixedWidth(110)
self.update_prices_progress.setRange(0, 100)
update_layout.addWidget(self.update_prices_button, 0, 0)
update_layout.addWidget(self.update_prices_progress, 0, 1)
self.update_ducats_button = QPushButton("Update Ducats")
self.update_ducats_button.clicked.connect(self.update_ducats)
self.update_ducats_progress = QProgressBar()
self.update_ducats_progress.setFixedWidth(110)
self.update_ducats_progress.setRange(0, 100)
update_layout.addWidget(self.update_ducats_button, 1, 0)
update_layout.addWidget(self.update_ducats_progress, 1, 1)
last_updated_prices_label = QLabel("Prices Updated")
prices = self.settings.value("last_updated_prices_value", defaultValue="Never", type=str)
ducats = self.settings.value("last_updated_ducats_value", defaultValue="Never", type=str)
num_parts = self.settings.value("num_parts_value", defaultValue=350, type=str)
latest_item = self.settings.value("latest_item_value", defaultValue="", type=str)
self.last_updated_prices_value = QLabel(prices)
self.last_updated_ducats_value = QLabel(ducats)
self.num_parts_value = QLabel(num_parts)
self.latest_item_value = QLabel(latest_item)
update_layout.addWidget(last_updated_prices_label, 2, 0)
update_layout.addWidget(self.last_updated_prices_value, 2, 1)
last_updated_ducats_label = QLabel("Ducats Updated")
update_layout.addWidget(last_updated_ducats_label, 3, 0)
update_layout.addWidget(self.last_updated_ducats_value, 3, 1)
num_parts_label = QLabel("Prime Parts")
update_layout.addWidget(num_parts_label, 4, 0)
update_layout.addWidget(self.num_parts_value, 4, 1)
latest_item_label = QLabel("Latest Prime")
update_layout.addWidget(latest_item_label, 5, 0)
update_layout.addWidget(self.latest_item_value, 5, 1)
update_box = QGroupBox("Updates")
update_box.setLayout(update_layout)
return update_box
def init_sliders(self):
self.slider_names = ['x', 'y', 'w', 'h', 'v1', 'v2', 'd', 'Screencap (hz)', 'Fissure (s)', 'API Threads']
self.sliders = {x: QSlider(Qt.Horizontal) for x in self.slider_names}
self.slider_labels = {x: QLabel(x) for x in self.slider_names}
self.slider_default_values = {}
self.slider_orig_values = {'x': 521, 'y': 400, 'w': 908, 'h': 70, 'v1': 197, 'v2': 180, 'd': 4,
'Screencap (hz)': 1, 'Fissure (s)': 30, 'API Threads': 4}
for slider_name in self.slider_names:
self.slider_default_values[slider_name] = self.settings.value(slider_name, defaultValue=self.slider_orig_values[slider_name])
self.slider_values = {x: QLabel(str(self.slider_default_values[x])) for x in self.slider_names}
self.slider_values['Screencap (hz)'].setNum(self.slider_default_values['Screencap (hz)']/4)
self.slider_values['d'].setNum(self.slider_default_values['d'] / 4)
self.slider_labels['d'].setText('\u0394')
self.sliders['x'].setMaximum(int(self.warframe_width / 2))
self.sliders['y'].setMaximum(int(self.warframe_height / 2))
self.sliders['w'].setMaximum(self.warframe_width)
self.sliders['h'].setMaximum(self.warframe_height)
self.sliders['v1'].setMaximum(255)
self.sliders['v2'].setMaximum(255)
self.sliders['d'].setMaximum(40)
self.sliders['Screencap (hz)'].setMaximum(20)
self.sliders['Screencap (hz)'].setMinimum(1)
self.sliders['Fissure (s)'].setMaximum(60)
self.sliders['Fissure (s)'].setMinimum(10)
self.sliders['API Threads'].setMaximum(10)
self.sliders['API Threads'].setMinimum(2)
for slider_name in self.slider_names:
if len(slider_name) <= 2:
self.sliders[slider_name].setMinimum(0)
self.sliders[slider_name].setSingleStep(1)
self.slider_values[slider_name].setFixedWidth(35)
self.sliders[slider_name].setValue(self.slider_default_values[slider_name])
def init_tables(self):
self.table = QTableWidget(7, 3)
self.table.setHorizontalHeaderLabels(['Prime Part', 'Plat', 'Ducats'])
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
header = self.table.horizontalHeader()
header.setSectionResizeMode(0, QHeaderView.Stretch)
header.setSectionResizeMode(1, QHeaderView.ResizeToContents)
header.setSectionResizeMode(2, QHeaderView.ResizeToContents)
self.mission_table = QTableWidget(30, 4)
self.mission_table.setHorizontalHeaderLabels(['Relic', 'Mission', 'Type', 'Time Left'])
self.mission_table.setEditTriggers(QAbstractItemView.NoEditTriggers)
mission_header = self.mission_table.horizontalHeader()
for i in range(4):
mission_header.setSectionResizeMode(i, QHeaderView.Interactive)
mission_header.resizeSection(0, 55)
mission_header.resizeSection(1, 150)
mission_header.resizeSection(2, 90)
mission_header.resizeSection(3, 60)
self.mission_table.setFixedWidth(405)
def update_prices(self):
self.prices_thread = threading.Thread(name="prices_thread", target=self.market_api.update_prices)
self.prices_thread.start()
self.update_prices_button.setEnabled(False)
self.update_ducats_button.setEnabled(False)
def update_ducats(self):
self.ducats_thread = threading.Thread(name="ducats_thread", target=self.market_api.update_ducats)
self.ducats_thread.start()
self.update_prices_button.setEnabled(False)
self.update_ducats_button.setEnabled(False)
def update_primes_info(self, num, latest):
self.num_parts_value.setNum(num)
self.latest_item_value.setText(latest)
self.update_prices_progress.setMaximum(num)
self.update_ducats_progress.setMaximum(num)
self.num_primes = num
def get_datetime(self):
return datetime.now().strftime("%b %d %Y %H:%M:%S")
def update_ducats_time(self):
self.last_updated_ducats_value.setText(self.get_datetime())
self.ducats_progress_lock.acquire()
self.update_ducats_progress.setValue(self.num_primes)
self.ducats_progress_lock.release()
self.settings.setValue("last_updated_ducats_value", self.last_updated_ducats_value.text())
self.settings.setValue("num_parts_value", self.num_parts_value.text())
self.settings.setValue("latest_item_value", self.latest_item_value.text())
def update_prices_time(self):
self.last_updated_prices_value.setText(self.get_datetime())
self.prices_progress_lock.acquire()
self.update_prices_progress.setValue(self.num_primes)
self.prices_progress_lock.release()
self.settings.setValue("last_updated_prices_value", self.last_updated_prices_value.text())
self.settings.setValue("num_parts_value", self.num_parts_value.text())
self.settings.setValue("latest_item_value", self.latest_item_value.text())
def set_update_prices_progress(self, val):
if self.prices_progress_lock.acquire():
self.update_prices_progress.setValue(val)
self.prices_progress_lock.release()
def set_update_ducats_progress(self, val):
if self.ducats_progress_lock.acquire():
self.update_ducats_progress.setValue(val)
self.ducats_progress_lock.release()
def finished_update_progress(self):
self.update_prices_button.setEnabled(True)
self.update_ducats_button.setEnabled(True)
def show_preferences(self):
self.dialog.exec_()
self.load_settings()
def toggle_fissure_table(self):
if self.hide_fissure_check_box.isChecked():
self.mission_table.hide()
else:
self.mission_table.show()
self.setFixedSize(self.layout.sizeHint())
def toggle_move_to_top(self):
self.ocr.set_move_to_top(self.move_to_top_check_box.isChecked())
def toggle_cropped_img(self):
if self.hide_crop_check_box.isChecked():
self.crop_img.hide()
else:
self.crop_img.show()
self.setFixedSize(self.layout.sizeHint())
def toggle_filtered_img(self):
if self.hide_filter_check_box.isChecked():
self.filter_img.hide()
else:
self.filter_img.show()
self.setFixedSize(self.layout.sizeHint())
#print("{}h,{}w".format(self.frameGeometry().height(),self.frameGeometry().width()))
def set_sliders_range(self, x, y):
max_values = {'x': int(x/2), 'y': int(y/2), 'w':x, 'h':y}
for slider_name in max_values:
self.sliders[slider_name].setMaximum(max_values[slider_name])
self.sliders[slider_name].setValue(self.slider_default_values[slider_name])
self.settings.setValue("{}_max", max_values[slider_name])
def toggle_button(self):
self.is_paused = not self.is_paused
if self.is_paused:
self.pause_button.setText("Resume")
else:
self.pause_button.setText("Pause")
if self.ocr is not None:
if self.is_paused:
self.ocr.save_screenshot()
self.ocr.skip_screenshot = True
else:
self.ocr.skip_screenshot = False
def clear_table(self):
self.table.clearSelection()
self.table.clearContents()
self.filled_rows = 0
#self.table.setRowCount(self.filled_rows)
def is_plat_preferred(self):
return self.plat_check_box.isChecked()
def insert_table_row(self, row):
for i in range(3):
self.table.setItem(self.filled_rows, i, QTableWidgetItem(str(row[i])))
self.filled_rows = self.filled_rows + 1
#self.table.setRowCount(self.filled_rows)
def update_mission_table(self, missions):
self.missions = list(missions)
cur_time = time.time()
for i in range(len(missions)):
for j in range(3):
self.mission_table.setItem(i, j, QTableWidgetItem(str(self.missions[i][j])))
self.mission_table.setItem(i, 3, QTableWidgetItem(self.get_duration_str(self.missions[i][3]-cur_time)))
if self.missions[i][0] in self.hidden_relics:
self.mission_table.setRowHidden(i, True)
if self.missions[i][2] in self.hidden_missions:
self.mission_table.setRowHidden(i, True)
else:
self.mission_table.setRowHidden(i, False)
self.mission_table.setRowCount(len(self.missions)-1)
def update_mission_table_time(self):
cur_time = time.time()
needs_update = False
for i in range(len(self.missions)):
self.mission_table.setItem(i, 3, QTableWidgetItem(self.get_duration_str(self.missions[i][3]-cur_time)))
if self.missions[i][3]-cur_time < 0:
needs_update = True
if needs_update:
self.api.filter_expired_missions()
def update_mission_table_hidden(self):
for i in range(len(self.missions)):
if self.missions[i][0] in self.hidden_relics:
self.mission_table.setRowHidden(i, True)
elif self.missions[i][2] in self.hidden_missions:
self.mission_table.setRowHidden(i, True)
else:
self.mission_table.setRowHidden(i, False)
def get_duration_str(self, duration):
m, s = divmod(int(duration), 60)
h, m = divmod(m, 60)
return '{:d}:{:02d}:{:02d}'.format(h, m, s)
def set_ocr_connection(self, ocr):
for slider_name in self.slider_names:
self.sliders[slider_name].valueChanged.connect(partial(self.set_ocr_crop, ocr, slider_name))
self.ocr = ocr
self.market_api = MarketReader(ocr=self.ocr, gui=self)
def set_api(self, wf_api):
self.api = wf_api
self.make_hide_missions_box(self.api.mission_types)
def set_hidden_relic(self, relic):
if self.hide_relics[relic].isChecked():
self.hidden_relics.add(relic)
else:
self.hidden_relics.remove(relic)
self.update_mission_table_hidden()
def set_ocr_crop(self, ocr, dim, val):
if dim == 'Screencap (hz)' or dim == 'd':
val = val / 4
self.slider_values[dim].setNum(val)
if val < 0 or val > 100000 or val is None:
return
if dim == 'x':
ocr.set_x_offset(val)
if dim == 'y':
ocr.set_y_offset(val)
if dim == 'w':
ocr.set_w(val)
if dim == 'h':
ocr.set_h(val)
if dim == 'v1':
ocr.set_v1(val)
if dim == 'v2':
ocr.set_v2(val)
if dim == 'd':
self.ocr.set_diff_threshold(val/4)
if dim == 'Screencap (hz)':
ocr.set_interval(1/val)
if dim == 'Fissure (s)':
self.api.set_rate(val)
if dim == 'API Threads':
self.market_api.set_num_threads(val)
#def select_max(self):
# # TODO doesnt work
# self.table.clearSelection()
# self.table.selectRow(self.max_row)
def update_filtered(self, filtered):
filtered_shape = None
if not self.hide_filter_check_box.isChecked():
filtered_shape = filtered.shape
h, w = filtered.shape
bytes_per_line = w
filtered_pix = QPixmap(QImage(filtered, w, h, bytes_per_line, QImage.Format_Grayscale8))
filtered_pix = filtered_pix.scaled(908, 70, Qt.KeepAspectRatio)
self.image_label2.setPixmap(filtered_pix)
#self.update_window_size(None, filtered_shape)
def update_screenshot(self, screenshot):
screenshot_shape = None
if not self.hide_crop_check_box.isChecked():
screenshot_shape = screenshot.shape
h, w, ch = screenshot.shape
bytes_per_line = ch * w
screenshot_pix = QPixmap(QImage(screenshot, w, h, bytes_per_line, QImage.Format_RGB888))
screenshot_pix = screenshot_pix.scaled(908, 70, Qt.KeepAspectRatio)
self.image_label.setPixmap(screenshot_pix)
#self.update_window_size(screenshot_shape, None)
def update_window_size(self, screenshot_shape, filtered_shape):
should_update = False
if screenshot_shape is not None and screenshot_shape == self.old_screenshot_shape:
self.old_screenshot_shape = screenshot_shape
should_update = True
if filtered_shape is not None and filtered_shape == self.old_filtered_shape:
self.old_filtered_shape = filtered_shape
should_update = True
if should_update:
self.setFixedSize(self.layout.sizeHint())
def __exit__(self):
self.market_api.exit_now = True
self.ocr.exit_now = True
class ledStrip(QWidget):
"""
[description]
**Arguments:**
None
**Keword Arguments:**
None
**Author:**
Chris Bruce, [email protected], 12/3/2018
"""
TITLE = "LED Strip Simluation"
VERSION = 1.0
SIZE = [300, 400]
PIXEL_MIN = 8
PIXEL_MAX = 256
PIXEL_NUM = 32
PIXEL_SIZE_MIN = 8
PIXEL_SIZE_MAX = 64
STRIP_COLOR = const.grey # default RGB value for the strip
PIXEL_COLOR = Color(12, 12, 12) # default RGB value for LED pixel
#STYLE_SHEET = "QWidget{ background-color: rgb{} };".format( str( STRIP_COLOR ) )
STYLE_SHEET = "QWidget{ background-color:white};"
def __init__(self, app):
super(ledStrip, self).__init__()
self.app = app
self.pixels = [] # array of LED pixels
self.pixel_size = 32 # size of each LED pixel
self.pixel_space = 16 # size of space between each LED pixel
self.paused = False
self.testing = False
self._init_gui()
def _init_gui(self):
"""
[description]
**Arguments:**
None
**Keword Arguments:**
None
**Author:**
Chris Bruce, [email protected], 12/3/2018
"""
self.setWindowTitle('{} - ver. {}'.format(self.TITLE, self.VERSION))
self.main_layout = QVBoxLayout()
self.main_layout.setSpacing(self.pixel_space)
self.setLayout(self.main_layout)
self.setAutoFillBackground(True)
self._strip_color()
# size_policy = QSizePolicy( )
# size_policy.setHorizontalPolicy( QSizePolicy.Minimum )
# self.setSizePolicy( size_policy )
self.main_layout.addWidget(self._create_strip())
self.main_layout.addWidget(self._create_controls())
self._update_gui()
def _create_controls(self):
"""
[description]
**Arguments:**
None
**Keword Arguments:**
None
**Returns:**
:``[type]``: [description]
**Author:**
Chris Bruce, [email protected], 12/3/2018
"""
widget = QWidget() #QGroupBox( 'Settings:' )
layout = QHBoxLayout()
widget.setLayout(layout)
label_num = QLabel('LEDs:')
spin_num = QSpinBox()
spin_num.setRange(self.PIXEL_MIN, self.PIXEL_MAX)
spin_num.setFixedWidth(64)
spin_num.setValue(self.PIXEL_NUM)
spin_num.valueChanged.connect(self._on_spin_num_changed)
label_size = QLabel('Size:')
spin_size = QSpinBox()
spin_size.setRange(self.PIXEL_SIZE_MIN, self.PIXEL_SIZE_MAX)
spin_size.setFixedWidth(64)
spin_size.setValue(self.pixel_size)
spin_size.valueChanged.connect(self._on_spin_size_changed)
label_space = QLabel('Space:')
spin_space = QSpinBox()
spin_space.setRange(0, 256)
spin_space.setFixedWidth(64)
spin_space.setValue(self.pixel_space)
spin_space.valueChanged.connect(self._on_spin_space_changed)
self.tests = QComboBox()
for test in sorted(tests.keys()):
self.tests.addItem(test)
# self.tests.setCurrentText( 'Soft Fade' )
btn_start = QPushButton('Start')
btn_start.pressed.connect(self._on_btn_start_pressed)
btn_pause = QPushButton('Pause')
btn_pause.pressed.connect(self._on_btn_pause_pressed)
btn_stop = QPushButton('Stop')
btn_stop.pressed.connect(self._on_btn_stop_pressed)
layout.addStretch()
layout.addWidget(label_num)
layout.addWidget(spin_num)
layout.addWidget(label_size)
layout.addWidget(spin_size)
layout.addWidget(label_space)
layout.addWidget(spin_space)
layout.addWidget(self.tests)
layout.addWidget(btn_start)
layout.addWidget(btn_pause)
layout.addWidget(btn_stop)
layout.addStretch()
return widget
def _create_pixel(self, color):
"""
[description]
**Arguments:**
:``color``: `[type]` [description]
**Keword Arguments:**
None
**Returns:**
:``[type]``: [description]
**Author:**
Chris Bruce, [email protected], 12/3/2018
"""
pixel = QFrame()
pixel.setFixedSize(QSize(self.pixel_size, self.pixel_size))
pixel.setFrameShape(QFrame.Box)
pixel.setFrameShadow(QFrame.Raised)
pixel.setLineWidth(0)
pixel.setMidLineWidth(self.pixel_size / 8)
pixel.setStyleSheet("background-color: rgb{}".format(color))
return pixel
def _create_strip(self):
"""
[description]
**Arguments:**
None
**Keword Arguments:**
None
**Returns:**
:``[type]``: [description]
**Author:**
Chris Bruce, [email protected], 12/3/2018
"""
self.strip_widget = QWidget()
self.strip_layout = QHBoxLayout()
self.strip_layout.setSpacing(self.pixel_space)
self.strip_widget.setLayout(self.strip_layout)
for i in range(self.PIXEL_NUM):
pixel = self._create_pixel(self.PIXEL_COLOR)
self.pixels.append(pixel)
self.strip_layout.addWidget(pixel)
return self.strip_widget
def _strip_color(self, color=STRIP_COLOR):
"""
Change the color of the strip
**Arguments:**
None
**Keword Arguments:**
None
**Returns:**
:``[type]``: [description]
**Author:**
Chris Bruce, [email protected], 12/3/2018
"""
p = self.palette()
p.setColor(self.backgroundRole(), QColor(*color))
self.setPalette(p)
return color
def _update_size(self):
self.strip_widget.setFixedSize(self.strip_layout.sizeHint())
self.setFixedSize(self.main_layout.sizeHint())
self._center()
return True
def _center(self):
qtRectangle = self.frameGeometry()
centerPoint = QDesktopWidget().availableGeometry().center()
qtRectangle.moveCenter(centerPoint)
self.move(qtRectangle.topLeft())
return qtRectangle.topLeft()
def _update_gui(self):
self._update_size()
self._center()
return True
def _on_spin_num_changed(self, value):
"""
Change the color of the strip
**Arguments:**
None
**Keword Arguments:**
None
**Returns:**
:``[type]``: [description]
**Author:**
Chris Bruce, [email protected], 12/3/2018
"""
num_pixels = self.numPixels()
if value > num_pixels:
for _ in range(value - num_pixels):
pixel = self._create_pixel(self.PIXEL_COLOR)
self.pixels.append(pixel)
self.strip_layout.addWidget(pixel)
elif value < len(self.pixels):
for _ in range(num_pixels - value):
pixel = self.pixels[-1]
self.strip_layout.removeWidget(pixel)
self.pixels.pop()
pixel.deleteLater()
self._update_gui()
def _on_spin_size_changed(self, value):
"""
Change the color of the strip
**Arguments:**
None
**Keword Arguments:**
None
**Returns:**
:``[type]``: [description]
**Author:**
Chris Bruce, [email protected], 12/3/2018
"""
for pixel in self.pixels:
self.pixel_size = value
pixel.setFixedSize(QSize(self.pixel_size, self.pixel_size))
pixel.setMidLineWidth(self.pixel_size / 8)
self._update_gui()
def _on_spin_space_changed(self, value):
"""
Change the color of the strip
**Arguments:**
None
**Keword Arguments:**
None
**Returns:**
:``[type]``: [description]
**Author:**
Chris Bruce, [email protected], 12/3/2018
"""
self.pixel_space = value
self.strip_layout.setSpacing(self.pixel_space)
self._update_gui()
def _on_btn_start_pressed(self):
self.testing = True
sel_test = self.tests.currentText()
test_func = tests[sel_test]
return test_func(self)
def _on_btn_pause_pressed(self):
self.paused = not self.paused
return True
def _on_btn_stop_pressed(self):
self.testing = False
return True
def numPixels(self):
"""
[description]
**Arguments:**
None
**Keword Arguments:**
None
**Returns:**
:``[type]``: [description]
**Author:**
Chris Bruce, [email protected], 12/3/2018
"""
return len(self.pixels)
def setPixelColor(self, i, color):
"""
[description]
**Arguments:**
:``i``: `[type]` [description]
:``color``: `[type]` [description]
**Keword Arguments:**
None
**Returns:**
:``[type]``: [description]
**Author:**
Chris Bruce, [email protected], 12/3/2018
"""
if color == 0:
color = self.PIXEL_COLOR
if i > (self.numPixels() - 1):
i -= self.numPixels()
pixel = self.pixels[i]
pixel.setStyleSheet("background-color: rgb{}".format(color))
return True
def show(self):
"""
Extends QWidget's .show( ) so it can function similuarly as NeoPixel calls
**Author:**
Chris Bruce, [email protected], 12/3/2018
"""
super(ledStrip, self).show()
# extended functionality
self.app.processEvents()
def closeEvent(self, event):
print("Closing")
self._on_btn_stop_pressed()
self.destroy()
self.app.exit()
class myColorHistogram(QtWidgets.QWidget):
def process(self):
self.value = self.value_textbox.text()
self.hue = self.hue_textbox.text()
self.saturation = self.saturation_textbox.text()
self.img_path = self.dir_label.text()
print(self.value)
print(self.hue)
print(self.saturation)
self.myThread = colorhist_thread(self.hue, self.saturation, self.value,
self.img_path, self.output_string)
self.myThread.started.connect(self.start)
self.myThread.start()
self.myThread.finished.connect(self.please_done)
def selectfolderpartial(self, btn):
pathfolder = QFileDialog.getExistingDirectory(self,
'Select a directory')
if (btn == self.select_dir_button):
pathfolder = pathfolder + "/"
self.dir_label.setText(pathfolder)
self.dir_string = pathfolder
self.dir_label.setFixedWidth(500)
def saveFileDialog(self):
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
fileName, _ = QFileDialog.getSaveFileName(
self,
"Save as *.csv and *.npy",
"",
"All Files (*);;Text Files (*.txt)",
options=options)
self.output_label.setText(fileName)
self.output_string = fileName
def fontInit(self):
self.fonth1 = QFont()
self.fonth1.setPointSize(12)
self.fonth1.setBold(True)
def initMainLayout(self):
# Title
self.title = QLabel('Color Histogram')
self.title.setObjectName("label_file")
self.title.setAlignment(QtCore.Qt.AlignHCenter)
self.title.setFont(self.fonth1)
################################################
self.mainlayout = QVBoxLayout()
self.mainlayout.setAlignment(QtCore.Qt.AlignTop)
self.setLayout(self.mainlayout)
self.secondLayout = QGridLayout()
self.mainlayout.addWidget(self.title)
self.mainlayout.addLayout(self.secondLayout)
def initLayout(self):
# label hue Rule
self.hue_label = QLabel('Nilai kuantisasi hue')
############################################
# Input hue operator mblbp
self.hue_textbox = QLineEdit(self)
self.hue_textbox.setMaximumWidth(100)
self.hue_textbox.setFixedWidth(100)
reg_ex = QtCore.QRegExp("\d+")
self.hue_textbox.setText("0")
input_validator = QtGui.QRegExpValidator(reg_ex, self.hue_textbox)
self.hue_textbox.setValidator(input_validator)
############################################
# label saturation Rule
self.saturation_label = QLabel('Nilai kuantisasi saturation')
############################################
# Input saturation operator mblbp
self.saturation_textbox = QLineEdit(self)
self.saturation_textbox.setMaximumWidth(100)
self.saturation_textbox.setFixedWidth(100)
reg_ex = QtCore.QRegExp("\d+")
self.saturation_textbox.setText("0")
input_validator = QtGui.QRegExpValidator(reg_ex,
self.saturation_textbox)
self.saturation_textbox.setValidator(input_validator)
############################################
# label value Rule
self.value_label = QLabel('Nilai kuantisasi value')
############################################
# Input value operator mblbp
self.value_textbox = QLineEdit(self)
self.value_textbox.setMaximumWidth(100)
self.value_textbox.setFixedWidth(100)
reg_ex = QtCore.QRegExp("\d+")
self.value_textbox.setText("0")
input_validator = QtGui.QRegExpValidator(reg_ex, self.value_textbox)
self.value_textbox.setValidator(input_validator)
############################################
self.secondLayout.addWidget(self.hue_textbox, 1, 0)
self.secondLayout.addWidget(self.hue_label, 1, 1)
self.secondLayout.addWidget(self.saturation_textbox, 2, 0)
self.secondLayout.addWidget(self.saturation_label, 2, 1)
self.secondLayout.addWidget(self.value_textbox, 3, 0)
self.secondLayout.addWidget(self.value_label, 3, 1)
############################################
# button Select Directory Image
self.select_dir_button = QPushButton('Select Folder')
self.select_dir_button.setMinimumSize(QtCore.QSize(100, 30))
self.select_dir_button.setMaximumSize(QtCore.QSize(100, 30))
self.select_dir_button.setObjectName("pushButton")
self.select_dir_button.clicked.connect(
partial(self.selectfolderpartial, self.select_dir_button))
############################################
# label dir
self.dir_label = QLabel('Folder dataset PETA')
############################################
# button Output
self.output_button = QPushButton('Output')
self.output_button.setMinimumSize(QtCore.QSize(100, 30))
self.output_button.setMaximumSize(QtCore.QSize(100, 30))
self.output_button.setObjectName("pushButton")
self.output_button.clicked.connect(self.saveFileDialog)
############################################
# label Output
self.output_label = QLabel('')
############################################
# button Process
self.process_button = QPushButton('Process')
self.process_button.setMinimumSize(QtCore.QSize(100, 30))
self.process_button.setMaximumSize(QtCore.QSize(100, 30))
self.process_button.setObjectName("pushButton")
self.process_button.clicked.connect(self.process)
############################################
# label Process
self.process_label = QLabel('')
############################################
self.secondLayout.addWidget(self.select_dir_button, 4, 0)
self.secondLayout.addWidget(self.dir_label, 4, 1)
self.secondLayout.addWidget(self.output_button, 5, 0)
self.secondLayout.addWidget(self.output_label, 5, 1)
self.secondLayout.addWidget(self.process_button, 6, 0)
self.secondLayout.addWidget(self.process_label, 6, 1)
def initGlobalVariable(self):
self.hue = ''
self.saturation = ''
self.value = ''
self.img_path = ''
self.output_string = ''
def setEnabledWidget(self, stat):
self.hue_textbox.setEnabled(stat)
self.saturation_textbox.setEnabled(stat)
self.value_textbox.setEnabled(stat)
self.select_dir_button.setEnabled(stat)
self.output_button.setEnabled(stat)
self.process_button.setEnabled(stat)
def start(self):
self.setEnabledWidget(False)
self.process_label.setText("Silahkan Tunggu")
def please_done(self):
self.setEnabledWidget(True)
self.process_label.setText("Berhasil")
self.myThread.terminate()
def __init__(self, parent=None):
super(myColorHistogram, self).__init__(parent)
self.fontInit()
self.initMainLayout()
self.initLayout()
self.setMinimumSize(self.mainlayout.sizeHint())
class MainUsage(QMainWindow):
"""Main window of the application, kept simple and designed
to be used by people who award certificates."""
def __init__(self):
super(MainUsage, self).__init__()
if not ls.load_language():
ls.select_language("en")
# continuously check connection in background
self.check_connection_in_thread()
# checking if a register has previously been loaded
self.registre = Registre() # empty register
self.school_name = "" # also serves as indicator that a register has been loaded
if os.path.exists("school_name.txt") and os.path.exists("p.rc"):
with open("school_name.txt", "r") as f:
self.school_name = f.read()
with open("p.rc") as f:
p = f.read()
try:
# if local files exist, download from cloud
if self.school_name \
and cloud_support.download_registre(self.school_name, p):
self.registre = Registre()
self.registre.charger()
except KeyError:
self.school_name = ""
open("school_name.txt", "w").close()
# if no register is loaded, settings_window serves as first screen to
# guide user through creating/loading a new register
if not self.school_name:
self.show_settings()
self.registre_updated_flag = False
self.thread_running_flag = False
self.lay_out()
def lay_out(self):
"""lays out main window on initialization
and connects button callbacks"""
self.setWindowTitle(ls.strings.TITLE)
self.layout = QVBoxLayout()
self.title = QLabel(ls.strings.TITLE)
self.title.setFont(QFont("unknown", 13))
self.title.setAlignment(Qt.AlignCenter)
self.param_imprim = QWidget()
self.h_layout = QHBoxLayout()
self.h_layout.setContentsMargins(0, 0, 0, 0)
self.parametres = QPushButton(ls.strings.PARAMETERS_BUTTON)
self.imprimer = QPushButton(ls.strings.PRINT_BUTTON)
self.h_layout.addWidget(self.parametres)
self.h_layout.addWidget(self.imprimer)
self.param_imprim.setLayout(self.h_layout)
self.membres = MyComboBox(placeholder=ls.strings.MEMBER_CB)
self.membres.setFont(QFont("unknown", 13))
self.membres.addItems([m.id for m in self.registre.membres])
self.categories = MyComboBox(placeholder=ls.strings.CATEG_CB)
self.categories.setFont(QFont("unknown", 13))
self.categories.addItems([c for c in self.registre.categories])
self.cert_box = MyComboBox(placeholder=ls.strings.CERT_CB)
self.cert_box.setFont(QFont("unknown", 13))
self.status = QLabel()
self.status.setAlignment(Qt.AlignCenter)
self.status.setWordWrap(True)
self.status.setFont(QFont("unknown", 12))
self.decerner = QPushButton(ls.strings.AWARD_CERTIFICATE)
self.rendre_certificateur = QPushButton(
ls.strings.MAKE_CERTIFICATOR_BUTTON)
self.reinitialiser = QPushButton(ls.strings.REINITIALIZE_BUTTON)
self.thread_progress = QLabel(ls.strings.SAVED)
self.thread_progress.setAlignment(Qt.AlignRight)
self.thread_progress.setStyleSheet("color:grey")
self.layout.addWidget(self.title)
self.layout.addWidget(self.param_imprim)
self.layout.addWidget(self.membres)
self.layout.addWidget(self.categories)
self.layout.addWidget(self.cert_box)
self.layout.addWidget(self.status)
self.layout.addWidget(self.decerner)
self.layout.addWidget(self.rendre_certificateur)
self.layout.addWidget(self.reinitialiser)
self.layout.addWidget(self.thread_progress)
self.decerner.hide()
self.rendre_certificateur.hide()
self.reinitialiser.hide()
widget = QWidget()
widget.setLayout(self.layout)
self.setCentralWidget(widget)
self.resize(self.layout.sizeHint())
# ----------- connecting slots ---------------
self.parametres.clicked.connect(self.show_settings)
self.imprimer.clicked.connect(self.imprimer_callback)
self.decerner.clicked.connect(self.decerner_callback)
self.rendre_certificateur.clicked.connect(
self.rendre_certificateur_callback)
self.reinitialiser.clicked.connect(self.reinitialiser_callback)
self.membres.currentTextChanged.connect(self.update)
self.categories.currentTextChanged.connect(self.update)
self.cert_box.currentTextChanged.connect(self.update)
def update(self):
"""Frequently called function that updates both register data and UI"""
# ---------- updating register data ----------
if not self.school_name:
# first prompt screen if no school name
self.show_settings()
else:
if self.registre_updated_flag:
self.upload_in_thread()
else:
self.download_in_thread()
self.registre_updated_flag = False
# --------------- updating UI ---------------
self.update_comboboxes()
membre = self.membres.currentText()
certificat = self.cert_box.currentText()
m = self.registre.find_membre_by_id(membre)
c = self.registre.find_certificat_by_name(certificat)
if not m or not c:
self.rendre_certificateur.hide()
self.decerner.hide()
self.reinitialiser.hide()
if not m and not c:
msg = ""
elif m and not c:
_, msg = self.registre.get_certificats_for_member(m)
elif not m and c:
_, msg = self.registre.get_members_for_certificat(c)
else:
a, msg = self.registre.a_le_certificat(m, c)
if a == Registre.Certifie:
self.decerner.setText(ls.strings.REVOKE_CERTIFICATE)
self.decerner.show()
self.rendre_certificateur.show()
self.reinitialiser.hide()
elif a == Registre.Certificateur:
self.decerner.setText(ls.strings.REVOKE_CERTIFICATE)
self.decerner.show()
self.rendre_certificateur.hide()
self.reinitialiser.hide()
elif a == Registre.NonCertifie:
self.decerner.setText(ls.strings.AWARD_CERTIFICATE)
self.decerner.show()
self.rendre_certificateur.hide()
self.reinitialiser.hide()
elif a == Registre.CertificatPerdu:
self.decerner.setText(ls.strings.AWARD_CERTIFICATE)
self.decerner.show()
self.reinitialiser.show()
self.rendre_certificateur.hide()
self.status.setText(msg)
self.resize(
QSize(max(self.layout.sizeHint().width(), self.width()),
max(self.layout.sizeHint().height(), self.height())))
def update_comboboxes(self):
"""Loads data from self.registre into the members and category
widgets"""
saved_text_m = self.membres.currentText()
saved_text_cat = self.categories.currentText()
saved_text_cert = self.cert_box.currentText()
# prevent signals from retriggering self.update
self.membres.currentTextChanged.disconnect(self.update)
self.categories.currentTextChanged.disconnect(self.update)
self.cert_box.currentTextChanged.disconnect(self.update)
# deleting possibly obsolete data
self.membres.clear()
self.categories.clear()
self.cert_box.clear()
# filling in updated data
self.membres.addItems([m.id for m in self.registre.membres])
self.categories.addItems(self.registre.categories)
if saved_text_cat in self.registre.categories:
self.cert_box.addItems(
[c.nom for c in self.registre.get_certificats(saved_text_cat)])
else:
self.cert_box.addItems([c.nom for c in self.registre.certificats])
# restoring saved text
self.membres.setEditText(saved_text_m)
self.categories.setEditText(saved_text_cat)
self.cert_box.setEditText(saved_text_cert)
# reconnecting slots
self.membres.currentTextChanged.connect(self.update)
self.categories.currentTextChanged.connect(self.update)
self.cert_box.currentTextChanged.connect(self.update)
self.resize(self.layout.sizeHint())
def show_settings(self):
self.setWindowOpacity(0.)
settings_window = SettingsWindow(self)
settings_window.show()
def decerner_callback(self):
"""awards or removes a certificate to/from a member"""
membre = self.membres.currentText()
certificat = self.cert_box.currentText()
m = self.registre.find_membre_by_id(membre)
c = self.registre.find_certificat_by_name(certificat)
if not m or not c:
return
else:
if self.decerner.text() == ls.strings.REVOKE_CERTIFICATE:
if not confirm(ls.strings.REMOVE_CERTIFICATE_FROM(m.id,
c.nom)):
return
self.registre.decerner_certificat(
m, c, self.registre.CertificatPerdu)
self.rendre_certificateur.hide()
elif self.decerner.text() == ls.strings.AWARD_CERTIFICATE:
if not confirm(ls.strings.AWARD_CERTIFICATE_TO(m.id, c.nom)):
return
self.registre.decerner_certificat(m, c, self.registre.Certifie)
self.rendre_certificateur.show()
self.registre_updated_flag = True
self.update()
def rendre_certificateur_callback(self):
""" makes the person able to award the certificate
to someone else """
membre = self.membres.currentText()
certificat = self.cert_box.currentText()
m = self.registre.find_membre_by_id(membre)
c = self.registre.find_certificat_by_name(certificat)
if not (m and c):
return
else:
if not confirm(ls.strings.MAKE_CERTIFICATOR(m.id, c.nom)):
return
self.rendre_certificateur.hide()
self.registre.decerner_certificat(m, c,
self.registre.Certificateur)
self.registre_updated_flag = True
self.update()
def reinitialiser_callback(self):
""" Erase the history of a person who has lost a certificate (as if
they just never had the certificate) """
membre = self.membres.currentText()
certificat = self.cert_box.currentText()
m = self.registre.find_membre_by_id(membre)
c = self.registre.find_certificat_by_name(certificat)
if not (m and c):
return
else:
if not confirm(ls.strings.CLEAR_HISTORY(m.id, c.nom)):
return
self.rendre_certificateur.hide()
self.registre.decerner_certificat(m, c, self.registre.NonCertifie)
self.reinitialiser.hide()
self.registre_updated_flag = True
self.update()
def imprimer_callback(self):
""" generates a printable excel file """
excel.generer_registre(self.registre)
def upload_in_thread(self):
""" uploads local register to cloud in separate thread """
if self.thread_running_flag:
return
else:
self.thread_running_flag = True
self.thread = QThread()
self.uploader = multithreading.Uploader()
self.uploader.moveToThread(self.thread)
self.thread.started.connect(self.uploader.run)
self.uploader.finished.connect(self.thread.quit)
self.uploader.finished.connect(self.uploader.deleteLater)
self.thread.finished.connect(self.thread.deleteLater)
def finished():
self.thread_progress.setText(ls.strings.SAVED)
self.thread_running_flag = False
def started():
self.thread_progress.setText(ls.strings.SAVING)
self.uploader.finished.connect(finished)
self.uploader.started.connect(started)
self.registre.enregistrer()
self.thread.start()
def download_in_thread(self):
""" downloads register from cloud to local
file in separate thread """
if self.thread_running_flag:
return
else:
self.thread_running_flag = True
self.thread = QThread()
self.downloader = multithreading.Downloader()
self.downloader.moveToThread(self.thread)
self.thread.started.connect(self.downloader.run)
self.downloader.finished.connect(self.thread.quit)
self.downloader.finished.connect(self.downloader.deleteLater)
self.thread.finished.connect(self.thread.deleteLater)
def finished():
self.registre.charger()
self.update_comboboxes()
self.update()
self.thread_progress.setText(ls.strings.SAVED)
self.thread_running_flag = False
def started():
self.thread_progress.setText(ls.strings.SYNCHRONIZING)
self.downloader.finished.connect(finished)
self.downloader.started.connect(started)
self.thread.start()
def check_connection_in_thread(self):
""" continously checks if app is connected to internet """
self.check_thr = QThread()
self.checker = multithreading.ConnectionChecker()
self.checker.moveToThread(self.check_thr)
self.check_thr.started.connect(self.checker.run)
self.checker.finished.connect(self.check_thr.quit)
self.checker.finished.connect(self.checker.deleteLater)
self.check_thr.finished.connect(self.check_thr.deleteLater)
self.check_thr.start()
class myAdaboostTraining(QtWidgets.QWidget):
def process(self):
self.cf_string = self.cf_label.text()
self.mf_string = self.mf_label.text()
self.weak_class_string = self.weak_class_textbox.text()
self.myThread = guiadaboost_thread(self.cf_string, self.mf_string,
self.weak_class_string,
self.cv_string,
self.attr_label_string,
self.save_string)
self.myThread.started.connect(self.start)
self.myThread.start()
self.myThread.mySignal.connect(self.hello)
self.myThread.finished.connect(self.please_done)
def hello(self, result):
QMessageBox.information(self, "Pelatihan Berhasil", result)
print(result)
def selectfilepartial(self, btn):
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
fileName, _ = QFileDialog.getOpenFileName(self,
"Open file *.npy",
"",
"Numpy Files (*.npy)",
options=options)
if (btn == self.select_mf_button):
self.mf_label.setText(fileName)
self.mf_string = fileName
self.mf_label.setFixedWidth(500)
if (btn == self.select_cf_button):
self.cf_label.setText(fileName)
self.cf_string = fileName
self.cf_label.setFixedWidth(500)
def saveFileDialog(self):
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
fileName, _ = QFileDialog.getSaveFileName(self,
"Save as *.pkl",
"",
"Pickle Files (*.pkl)",
options=options)
fileName = fileName + ".pkl"
self.save_label.setText(fileName)
self.save_string = fileName
def fontInit(self):
self.fonth1 = QFont()
self.fonth1.setPointSize(12)
self.fonth1.setBold(True)
def initMainLayout(self):
# Title
self.title = QLabel('Adaboost Training')
self.title.setObjectName("label_file")
self.title.setAlignment(QtCore.Qt.AlignHCenter)
self.title.setFont(self.fonth1)
################################################
self.mainlayout = QVBoxLayout()
self.mainlayout.setAlignment(QtCore.Qt.AlignTop)
self.setLayout(self.mainlayout)
self.secondLayout = QGridLayout()
self.mainlayout.addWidget(self.title)
self.mainlayout.addLayout(self.secondLayout)
def initLayout(self):
# label weak classifier Rule
self.weak_class_label = QLabel('Jumlah Weak Classifier')
############################################
# Input weak classifier mblbp
self.weak_class_textbox = QLineEdit(self)
self.weak_class_textbox.setMaximumWidth(100)
self.weak_class_textbox.setFixedWidth(100)
reg_ex = QtCore.QRegExp("\d+")
self.weak_class_textbox.setText("0")
input_validator = QtGui.QRegExpValidator(reg_ex,
self.weak_class_textbox)
self.weak_class_textbox.setValidator(input_validator)
############################################
# label Cross Validation Rule
self.cv_label = QLabel('Cross Validation')
############################################
# Input saturation operator mblbp
self.cv = QComboBox()
# self.cv.addItems(["0", "2", "5", "10", "15"])
# self.cv.addItem("0", 0)
self.cv.addItem("2", 2)
self.cv.addItem("5", 5)
self.cv.addItem("10", 10)
self.cv.addItem("15", 15)
self.cv.currentIndexChanged.connect(self.selectionchangecv)
self.cv.setMaximumWidth(100)
############################################
############################################
# Input Attribute
self.attr_select = QComboBox()
self.attr_select.addItem('Laki-laki', 77)
self.attr_select.addItem('Celana Pendek', 88)
self.attr_select.addItem('Rambut Panjang', 49)
self.attr_select.addItem('Sandal', 85)
self.attr_select.addItem('Membawa Sesuatu', 81)
self.attr_select.addItem('Topi', 42)
self.attr_select.addItem('Tas Punggung', 28)
self.attr_select.currentIndexChanged.connect(self.selectionchangeattr)
self.attr_select.setMaximumWidth(100)
############################################
# label Cross Validation Rule
self.attr_label = QLabel('Label Atribut')
############################################
self.secondLayout.addWidget(self.weak_class_textbox, 1, 0)
self.secondLayout.addWidget(self.weak_class_label, 1, 1)
self.secondLayout.addWidget(self.cv, 2, 0)
self.secondLayout.addWidget(self.cv_label, 2, 1)
self.secondLayout.addWidget(self.attr_select, 3, 0)
self.secondLayout.addWidget(self.attr_label, 3, 1)
############################################
# button Select Color Feature
self.select_cf_button = QPushButton('Fitur Warna')
self.select_cf_button.setMinimumSize(QtCore.QSize(100, 30))
self.select_cf_button.setMaximumSize(QtCore.QSize(100, 30))
self.select_cf_button.setObjectName("pushButton")
self.select_cf_button.clicked.connect(
partial(self.selectfilepartial, self.select_cf_button))
############################################
# label Select Color Feature
self.cf_label = QLabel('')
############################################
# button Select MBLBP Feature
self.select_mf_button = QPushButton('Fitur Tekstur')
self.select_mf_button.setMinimumSize(QtCore.QSize(100, 30))
self.select_mf_button.setMaximumSize(QtCore.QSize(100, 30))
self.select_mf_button.setObjectName("pushButton")
self.select_mf_button.clicked.connect(
partial(self.selectfilepartial, self.select_mf_button))
############################################
# label dir
self.mf_label = QLabel('')
############################################
# Save Process
self.save_button = QPushButton('Output')
self.save_button.setMinimumSize(QtCore.QSize(100, 30))
self.save_button.setMaximumSize(QtCore.QSize(100, 30))
self.save_button.setObjectName("pushButton")
self.save_button.clicked.connect(self.saveFileDialog)
############################################
# label Save
self.save_label = QLabel('')
############################################
# button Process
self.process_button = QPushButton('Process')
self.process_button.setMinimumSize(QtCore.QSize(100, 30))
self.process_button.setMaximumSize(QtCore.QSize(100, 30))
self.process_button.setObjectName("pushButton")
self.process_button.clicked.connect(self.process)
############################################
# label Process
self.process_label = QLabel('')
############################################
self.secondLayout.addWidget(self.select_cf_button, 4, 0)
self.secondLayout.addWidget(self.cf_label, 4, 1)
self.secondLayout.addWidget(self.select_mf_button, 5, 0)
self.secondLayout.addWidget(self.mf_label, 5, 1)
self.secondLayout.addWidget(self.save_button, 6, 0)
self.secondLayout.addWidget(self.save_label, 6, 1)
self.secondLayout.addWidget(self.process_button, 7, 0)
self.secondLayout.addWidget(self.process_label, 7, 1)
def selectionchangecv(self, i):
print("Current index", self.cv.itemText(i))
print("Current Data", self.cv.itemData(i))
self.cv_string = self.cv.itemData(i)
def selectionchangeattr(self, i):
print("Current index", self.attr_select.itemText(i))
print("Current Data", self.attr_select.itemData(i))
self.attr_label_string = self.attr_select.itemData(i)
print(self.attr_label_string)
def initGlobalVariable(self):
self.weak_class_string = ''
self.cv_string = '2'
self.cf_string = ''
self.mf_string = ''
self.attr_label_string = '77'
self.save_string = ''
def setEnabledWidget(self, stat):
self.weak_class_textbox.setEnabled(stat)
self.select_cf_button.setEnabled(stat)
self.select_mf_button.setEnabled(stat)
self.attr_select.setEnabled(stat)
self.cv.setEnabled(stat)
self.process_button.setEnabled(stat)
def start(self):
self.setEnabledWidget(False)
self.process_label.setText("Silahkan Tunggu")
def please_done(self):
self.setEnabledWidget(True)
self.process_label.setText("Berhasil")
self.myThread.terminate()
def __init__(self, parent=None):
super(myAdaboostTraining, self).__init__(parent)
self.initGlobalVariable()
self.fontInit()
self.initMainLayout()
self.initLayout()
self.setMinimumSize(self.mainlayout.sizeHint())
def __init__(self, parent, active_data_types):
super(NewValueExtractorWindow, self).__init__(parent)
self.setAttribute(Qt.WA_DeleteOnClose) # This is required to stop background timers!
self.setWindowTitle('New Plot')
self.setModal(True)
self._active_data_types = active_data_types
self.on_done = print
# Message type selection box
self._type_selector = CommitableComboBoxWithHistory(self)
self._type_selector.setToolTip('Name of the message type to plot')
self._type_selector.setInsertPolicy(QComboBox.NoInsert)
type_completer = QCompleter(self._type_selector)
type_completer.setCaseSensitivity(Qt.CaseSensitive)
type_completer.setModel(self._type_selector.model())
self._type_selector.setCompleter(type_completer)
self._type_selector.setFont(get_monospace_font())
self._type_selector.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self._type_selector.setFocus(Qt.OtherFocusReason)
self._type_selector.currentTextChanged.connect(self._on_type_changed)
self._show_all_types_button = make_icon_button('puzzle-piece',
'Show all known message types, not only those that are '
'currently being exchanged over the bus',
self, checkable=True, on_clicked=self._update_data_type_list)
# Existence is torment.
self._extraction_expression_box = QLineEdit(self)
self._extraction_expression_box.setFont(get_monospace_font())
self._extraction_expression_box.setToolTip('Example: msg.cmd[0] / 16384')
# Node ID filter
self._node_id_filter_checkbox = QCheckBox('Accept messages only from specific node', self)
self._node_id_filter_checkbox.stateChanged.connect(
lambda: self._node_id_filter_spinbox.setEnabled(self._node_id_filter_checkbox.isChecked()))
self._node_id_filter_spinbox = QSpinBox(self)
self._node_id_filter_spinbox.setMinimum(1)
self._node_id_filter_spinbox.setMaximum(127)
self._node_id_filter_spinbox.setValue(1)
self._node_id_filter_spinbox.setEnabled(False)
# Expression filter
self._filter_expression_box = QLineEdit(self)
self._filter_expression_box.setFont(get_monospace_font())
self._filter_expression_box.setToolTip('Example: msg.esc_index == 3')
# Visualization options
self._selected_color = self.default_color_rotator.get()
self._select_color_button = make_icon_button('paint-brush', 'Select line color', self,
on_clicked=self._select_color)
self._select_color_button.setFlat(True)
_set_color(self._select_color_button, QPalette.Button, self._selected_color)
# Buttons
self._ok_button = make_icon_button('check', 'Create new extractor with these settings', self,
text='OK', on_clicked=self._on_ok)
# Layout
layout = QVBoxLayout(self)
msg_type_box = QGroupBox('Message type', self)
msg_type_box_layout = QHBoxLayout(self)
msg_type_box_layout.addWidget(self._show_all_types_button)
msg_type_box_layout.addWidget(self._type_selector, 1)
msg_type_box.setLayout(msg_type_box_layout)
layout.addWidget(msg_type_box)
expr_box = QGroupBox('Expression to plot', self)
expr_box_layout = QVBoxLayout(self)
expr_box_layout.addWidget(QLabel('Message is stored in the variable "msg"', self))
expr_box_layout.addWidget(self._extraction_expression_box)
expr_box.setLayout(expr_box_layout)
layout.addWidget(expr_box)
nid_filter_box = QGroupBox('Node ID filter', self)
nid_filter_box_layout = QHBoxLayout(self)
nid_filter_box_layout.addWidget(self._node_id_filter_checkbox)
nid_filter_box_layout.addWidget(self._node_id_filter_spinbox, 1)
nid_filter_box.setLayout(nid_filter_box_layout)
layout.addWidget(nid_filter_box)
field_filter_box = QGroupBox('Field filter', self)
field_filter_box_layout = QVBoxLayout(self)
field_filter_box_layout.addWidget(QLabel('Message is stored in the variable "msg"', self))
field_filter_box_layout.addWidget(self._filter_expression_box)
field_filter_box.setLayout(field_filter_box_layout)
layout.addWidget(field_filter_box)
vis_box = QGroupBox('Visualization', self)
vis_box_layout = QHBoxLayout(self)
vis_box_layout.addWidget(QLabel('Plot line color', self))
vis_box_layout.addWidget(self._select_color_button)
vis_box.setLayout(vis_box_layout)
layout.addWidget(vis_box)
layout.addWidget(self._ok_button)
self.setLayout(layout)
self.setFixedHeight(layout.sizeHint().height())
# Initialization
self._update_data_type_list()
self._on_type_changed()
class Multidialog(QDialog):
def __init__(self, screen, title, form_set, buttons=None, button_pressed=lambda:None):
if screen in window.screens:
self.screen = screen
super(Multidialog, self).__init__(window.screens[screen])
else:
self.screen = None
self.form_set = form_set
self.elements = {}
self.title = title
self.setWindowTitle(self.title)
self.main_layout = QVBoxLayout()
self.group_box = QGroupBox()
self.first_launch = True
layout = QFormLayout()
for f in self.form_set:
if not 'name' in f: continue
else:
self.elements[f['name']] = {k:f[k] for k in f}
e, l = self.get_element(etype=f['type'],
settings=f['settings'] if 'settings' in f else None,
data=f['data'] if 'data' in f else None,
label=f['label'] if 'label' in f else None)
self.elements[f['name']]['object'], self.elements[f['name']]['label'] = e, l
self.elements[f['name']]['callback'] = False
if 'settings' in f: self.elements[f['name']]['settings'] = f['settings']
layout.addRow(self.elements[f['name']]['label'], self.elements[f['name']]['object'])
self.initialize_settings()
if not buttons:
self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.button_box.accepted.connect(self.accept)
self.button_box.rejected.connect(self.reject)
else:
self.button_box = QDialogButtonBox(QDialogButtonBox.Reset | QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
#this needs some work
self.group_box.setLayout(layout)
self.main_layout.addWidget(self.group_box)
self.main_layout.addWidget(self.button_box)
self.setLayout(self.main_layout)
self.setFixedSize(self.main_layout.sizeHint())
def get_element(self, etype, settings, data, label):
widget = None
label = QLabel(label)
if etype.lower() == "input":
le = QLineEdit()
if data and isinstance(data, str): le.setText(data)
if settings and 'mode' in settings:
if settings["mode"] == "password": le.setEchoMode(QLineEdit.Password)
widget = le
elif etype.lower() == "dropdown":
cb = QComboBox()
cb.setFocusPolicy(Qt.StrongFocus)
# bugged on enter activate; to-do
# # QShortcut(QKeySequence(Qt.Key_Return), cb)
# cb.enterPressed.activated.connect(lambda: cb.showPopup)
if data:
if isinstance(data, list): cb.addItems(data)
elif isinstance(data, str): cb.addItem(data)
widget = cb
elif etype.lower() == "color":
cb = ColorButton()
if settings and 'pref' in settings:
cb.pref = settings['pref']
cb.color = prefs.get_pref(cb.pref)
elif 'color' in settings:
cb.color = settings['color']
cb.updateColor(cb.color)
widget = cb
return widget, label
def initialize_settings(self):
for el in self.elements:
e = self.elements[el]
if 'settings' in e:
settings = e['settings']
if 'conditional_show' in settings:
if 'element' in settings['conditional_show']:
if settings['conditional_show']['element'] in self.elements:
ref_e = settings['conditional_show']['element']
if 'callback' in self.elements[ref_e] and not self.elements[ref_e]['callback']:
if 'object' in self.elements[ref_e] and isinstance(self.elements[ref_e]['object'], QComboBox):
self.elements[ref_e]['object'].currentIndexChanged.connect(self.initialize_settings)
self.elements[ref_e]['callback'] = True
if 'object' in self.elements[ref_e]:
if 'not_state' in settings['conditional_show']:
sv = not (self.elements[ref_e]['object'].currentText() in settings['conditional_show']['not_state'])
e['object'].setVisible(sv)
e['label'].setVisible(sv)
elif 'state' in settings['conditional_show']:
sv = (self.elements[ref_e]['object'].currentText() in settings['conditional_show']['state'])
e['object'].setVisible(sv)
e['label'].setVisible(sv)
def refresh(self):
for w in self.group_box.children():
if isinstance(w, QLineEdit): w.setText("")
elif isinstance(w, QComboBox):
if w.count() > 0: w.setCurrentIndex(0)
def __init__(self, tag_sources, profile=None, parent=None):
super(TSProfileEdit, self).__init__(parent)
self.setWindowTitle(translate('Profile Editor',
'Edit Tag Source Config'))
winsettings('ts_profile_edit', self)
self.tag_sources = tag_sources
layout = QVBoxLayout(self)
self.setLayout(layout)
self.fields = QLineEdit(self)
layout.addLayout(
create_buddy(translate('Defaults', 'Fields: '), self.fields))
self.fields.setToolTip(translate('Profile Editor',
'<p>Enter a comma-seperated list of fields to retrieve. '
'Leave empty to retrieve all available fields/values. '
'<br /><br />Eg. <b>artist, album, title</b> will '
'only retrieve the artist, album and title fields of '
'from the Tag Source. '
'<br /><br />Start the list with '
'the tilde (~) character to write all retrieved fields '
', but the ones listed. Eg the field list '
'<b>~composer,__image</b> will write all fields but the '
'composer and __image (aka cover art) fields.</p>'
'<p>If a field has been retrieved in a previous '
'Tag Source the values will be combined if they differ. '
'Eg. If genre=<b>Rock</b> for the first tag source polled '
'and genre=<b>Alternative</b> for the tag source '
'polled second then the resulting field will have '
'multiple-values ie. genre=<b>Rock\\\\Rap</b>'))
self.replace_fields = QLineEdit(self)
layout.addLayout(create_buddy(translate('Profile Editor',
'Fields to replace: '), self.replace_fields))
self.replace_fields.setToolTip(translate('Profile Editor',
'Enter a comma-separated lists of fields that\'ll replace any '
'retrieved from previously polled tag sources. '
'<br />Start the list with the tilde (~) character to replace all '
'but the fields you list. <br />'
'<b>NB: Fields listed here must also be listed in the '
'list of fields to retrieve.</b>'
'<br /><br />Eg. Assume you have two Tag Sources. '
'The first retrieves <b>artist=Freshlyground, '
'album=Nomvula, genre=Afro Pop</b>. The second source gets '
'<b>artist=Freshly Ground, album=Nomvula, '
'genre=Pop</b>. '
'For the second Tag Source, setting just <b>artist</b> as the '
'list of fields to replace will overwrite the artist '
'field retrieved from the first tag source. '
'The resulting retrieved fields/values as shown in puddletag will '
'then be <b>artist=Freshly Ground, album=Nomvula, '
'genre=Afro Pop\\\\Pop</b>.'))
self.source = QComboBox()
self.source.addItems([source.name for source in tag_sources])
layout.addLayout(create_buddy(
translate('Profile Editor', '&Source'), self.source))
self.no_match = QComboBox()
self.no_match.addItems(NO_MATCH_OPTIONS)
layout.addLayout(create_buddy(translate('Profile Editor',
'&If no results found: '), self.no_match))
self.no_match.setToolTip(translate('Profile Editor',
'<p><b>Continue</b>: The lookup for the current album will continue '
'by checking the other tag sources if no matching results '
'were found for this tag source.</p>'
'<p><b>Stop:</b> The lookup for the current album will '
'stop and any previously retrieved results will be used.</p>'))
okcancel = OKCancel()
okcancel.ok.connect(self._okClicked)
okcancel.cancel.connect(self.close)
layout.addLayout(okcancel)
layout.addStretch()
self.setMaximumHeight(layout.sizeHint().height())
if profile:
self.setProfile(profile)
class Window(QDialog):
def setEnabledWidget(self, stat):
self.process_button.setEnabled(stat)
self.rule_button.setEnabled(stat)
self.label_data_button.setEnabled(stat)
self.select_dir_button.setEnabled(stat)
self.delimiter_textbox.setEnabled(stat)
self.extention_textbox.setEnabled(stat)
self.output_button.setEnabled(stat)
def start(self):
self.setEnabledWidget(False)
self.process_label.setText("Silahkan Tunggu")
def please_done(self):
self.setEnabledWidget(True)
self.process_label.setText("Berhasil")
self.myThread.terminate()
def process(self):
self.delimiter_string = self.delimiter_textbox.text()
self.extention_string = self.extention_textbox.text()
self.myThread = makeLabelThread(self.rule_string, self.label_string,
self.dir_string, self.extention_string,
self.delimiter_string,
self.output_string)
#self.connect(self.myThread, SIGNAL("started()"), self.start)
#self.connect(self.myThread, SIGNAL("finished()"), self.done)
self.myThread.started.connect(self.start)
self.myThread.start()
self.myThread.finished.connect(self.please_done)
def openfilepartial(self, btn):
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
fileName, _ = QFileDialog.getOpenFileName(None,
"Open *.csv",
"",
"Image Files (*.csv)",
options=options)
if btn == self.rule_button:
self.rule_file.setText(fileName)
self.rule_string = fileName
elif btn == self.label_data_button:
self.label_data_file.setText(fileName)
self.label_string = fileName
def selectfolderpartial(self, btn):
pathfolder = QFileDialog.getExistingDirectory(self,
'Select a directory')
if (btn == self.select_dir_button):
self.select_file.setText(pathfolder)
self.dir_string = pathfolder
def saveFileDialog(self):
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
fileName, _ = QFileDialog.getSaveFileName(
self,
"Save as *.csv and *.npy",
"",
"All Files (*);;Text Files (*.txt)",
options=options)
self.output_file.setText(fileName)
self.output_string = fileName
def fontInit(self):
self.fonth1 = QFont()
self.fonth1.setPointSize(12)
self.fonth1.setBold(True)
def initMainLayout(self):
# Title
self.title = QLabel(
'Converting Attribute Labels To Attribute Matrices')
self.title.setObjectName("label_file")
self.title.setAlignment(QtCore.Qt.AlignHCenter)
self.title.setFont(self.fonth1)
################################################
self.mainlayout = QVBoxLayout()
self.setLayout(self.mainlayout)
self.gridLayout = QGridLayout()
self.mainlayout.addWidget(self.title)
self.mainlayout.addLayout(self.gridLayout)
def initLeftLayout(self):
# button Search Rule
self.rule_button = QPushButton('Search Rule')
self.rule_button.setMinimumSize(QtCore.QSize(100, 30))
self.rule_button.setMaximumSize(QtCore.QSize(100, 30))
self.rule_button.setObjectName("pushButton")
self.rule_button.clicked.connect(
partial(self.openfilepartial, self.rule_button))
############################################
# button Search label
self.label_data_button = QPushButton('Search Label')
self.label_data_button.setMinimumSize(QtCore.QSize(100, 30))
self.label_data_button.setMaximumSize(QtCore.QSize(100, 30))
self.label_data_button.setObjectName("pushButton")
self.label_data_button.clicked.connect(
partial(self.openfilepartial, self.label_data_button))
############################################
# button Select Directory Image
self.select_dir_button = QPushButton('Select Folder')
self.select_dir_button.setMinimumSize(QtCore.QSize(100, 30))
self.select_dir_button.setMaximumSize(QtCore.QSize(100, 30))
self.select_dir_button.setObjectName("pushButton")
self.select_dir_button.clicked.connect(
partial(self.selectfolderpartial, self.select_dir_button))
############################################
# Input delimiter
self.delimiter_textbox = QLineEdit(self)
self.delimiter_textbox.setMaximumWidth(100)
self.delimiter_textbox.setFixedWidth(100)
############################################
# Input ekstensi gambar
self.extention_textbox = QLineEdit(self)
self.extention_textbox.setMaximumWidth(100)
self.extention_textbox.setFixedWidth(100)
############################################
# button Output
self.output_button = QPushButton('Output')
self.output_button.setMinimumSize(QtCore.QSize(100, 30))
self.output_button.setMaximumSize(QtCore.QSize(100, 30))
self.output_button.setObjectName("pushButton")
self.output_button.clicked.connect(self.saveFileDialog)
############################################
# button Process
self.process_button = QPushButton('Process')
self.process_button.setMinimumSize(QtCore.QSize(100, 30))
self.process_button.setMaximumSize(QtCore.QSize(100, 30))
self.process_button.setObjectName("pushButton")
self.process_button.clicked.connect(self.process)
############################################
self.gridLayout.addWidget(self.rule_button, 1, 0)
self.gridLayout.addWidget(self.label_data_button, 2, 0)
self.gridLayout.addWidget(self.select_dir_button, 3, 0)
self.gridLayout.addWidget(self.delimiter_textbox, 4, 0)
self.gridLayout.addWidget(self.extention_textbox, 5, 0)
self.gridLayout.addWidget(self.output_button, 6, 0)
self.gridLayout.addWidget(self.process_button, 7, 0)
def initRightLayout(self):
# label Search Rule
############################################
# label Search Rule
plusHeight = 500
self.rule_file = QLabel(
'File csv yang berisi list atribut dataset PETA yang akan diubah ke dalam bentuk matriks'
)
self.rule_file.setObjectName("label_file")
self.rule_file.setGeometry(
QtCore.QRect(self.rule_file.x(),
self.rule_file.y() + plusHeight,
self.rule_file.width(), self.rule_file.height()))
############################################
# label Search Label
self.label_data_file = QLabel(
'File label yang ada di setiap sub atribut peta yang telah diubah ke dalam bentuk matriks'
)
self.label_data_file.setObjectName("label_file")
self.label_data_file.setGeometry(
QtCore.QRect(self.label_data_file.x(),
self.label_data_file.y() + plusHeight,
self.label_data_file.width(),
self.label_data_file.width()))
############################################
# label Search Rule
self.title = QLabel(
'converting attribute labels to attribute matrices')
self.title.setObjectName("label_file")
self.title.setGeometry(
QtCore.QRect(self.title.x(), self.title.y(), self.title.width(),
self.title.height() + plusHeight))
############################################
# label Select Folder
self.select_file = QLabel('Pilih sub folder dari set data PETA')
self.select_file.setObjectName("label_file")
############################################
# label delimiter
self.delimiter_file = QLabel('Inputkan pembatas file')
self.delimiter_file.setObjectName("label_file")
############################################
# label Ekstensi
self.extention_file = QLabel('Inputkan ekstensi gambar')
self.extention_file.setObjectName("label_file")
############################################
# label Output
self.output_file = QLabel('')
self.output_file.setObjectName("label_file")
############################################
# label Output
self.process_label = QLabel('')
self.process_label.setObjectName("label_file")
############################################
self.gridLayout.addWidget(self.rule_file, 1, 1)
self.gridLayout.addWidget(self.label_data_file, 2, 1)
self.gridLayout.addWidget(self.select_file, 3, 1)
self.gridLayout.addWidget(self.delimiter_file, 4, 1)
self.gridLayout.addWidget(self.extention_file, 5, 1)
self.gridLayout.addWidget(self.output_file, 6, 1)
self.gridLayout.addWidget(self.process_label, 7, 1)
def initGlobalVariable(self):
self.rule_string = ''
self.label_string = ''
self.dir_string = ''
self.delimiter_string = ''
self.extention_string = ''
self.output_string = ''
def __init__(self, parent=None):
super(Window, self).__init__(parent)
self.fontInit()
self.initMainLayout()
self.initLeftLayout()
self.initRightLayout()
self.setFixedSize(self.mainlayout.sizeHint())
class myMblbplayout(QtWidgets.QWidget):
def process(self):
self.bin = self.bin_textbox.text()
self.height = self.height_textbox.text()
self.width = self.width_textbox.text()
self.img_path = self.dir_label.text()
print(self.bin)
print(self.height)
print(self.width)
print(self.img_path)
self.myThread = mblbpthread(self.height, self.width, self.bin,
self.img_path, self.output_string)
self.myThread.started.connect(self.start)
self.myThread.start()
self.myThread.finished.connect(self.please_done)
def selectfolderpartial(self, btn):
pathfolder = QFileDialog.getExistingDirectory(self,
'Select a directory')
if (btn == self.select_dir_button):
pathfolder = pathfolder + "/"
self.dir_label.setText(pathfolder)
self.dir_string = pathfolder
self.dir_label.setFixedWidth(500)
def saveFileDialog(self):
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
fileName, _ = QFileDialog.getSaveFileName(
self,
"Save as *.csv and *.npy",
"",
"All Files (*);;Text Files (*.txt)",
options=options)
self.output_label.setText(fileName)
self.output_string = fileName
def fontInit(self):
self.fonth1 = QFont()
self.fonth1.setPointSize(12)
self.fonth1.setBold(True)
def initMainLayout(self):
# Title
self.title = QLabel('Multi Block Local Binary Pattern')
self.title.setObjectName("label_file")
self.title.setAlignment(QtCore.Qt.AlignHCenter)
self.title.setFont(self.fonth1)
################################################
self.mainlayout = QVBoxLayout()
self.mainlayout.setAlignment(QtCore.Qt.AlignTop)
self.setLayout(self.mainlayout)
self.secondLayout = QGridLayout()
self.mainlayout.addWidget(self.title)
self.mainlayout.addLayout(self.secondLayout)
def initLayout(self):
# label Height Rule
self.height_label = QLabel('Tinggi deskriptor MB-LBP')
############################################
# Input height operator mblbp
self.height_textbox = QLineEdit(self)
self.height_textbox.setMaximumWidth(100)
self.height_textbox.setFixedWidth(100)
reg_ex = QtCore.QRegExp("\d+")
self.height_textbox.setText("0")
input_validator = QtGui.QRegExpValidator(reg_ex, self.height_textbox)
self.height_textbox.setValidator(input_validator)
############################################
# label Width Rule
self.width_label = QLabel('Lebar deksriptor MB-LBP')
############################################
# Input width operator mblbp
self.width_textbox = QLineEdit(self)
self.width_textbox.setMaximumWidth(100)
self.width_textbox.setFixedWidth(100)
reg_ex = QtCore.QRegExp("\d+")
self.width_textbox.setText("0")
input_validator = QtGui.QRegExpValidator(reg_ex, self.width_textbox)
self.width_textbox.setValidator(input_validator)
############################################
# label Bin Rule
self.bin_label = QLabel('Kuantisasi')
############################################
# Input bin operator mblbp
self.bin_textbox = QLineEdit(self)
self.bin_textbox.setMaximumWidth(100)
self.bin_textbox.setFixedWidth(100)
reg_ex = QtCore.QRegExp("\d+")
self.bin_textbox.setText("0")
input_validator = QtGui.QRegExpValidator(reg_ex, self.bin_textbox)
self.bin_textbox.setValidator(input_validator)
############################################
self.secondLayout.addWidget(self.height_textbox, 1, 0)
self.secondLayout.addWidget(self.height_label, 1, 1)
self.secondLayout.addWidget(self.width_textbox, 2, 0)
self.secondLayout.addWidget(self.width_label, 2, 1)
self.secondLayout.addWidget(self.bin_textbox, 3, 0)
self.secondLayout.addWidget(self.bin_label, 3, 1)
############################################
# button Select Directory Image
self.select_dir_button = QPushButton('Select Folder')
self.select_dir_button.setMinimumSize(QtCore.QSize(100, 30))
self.select_dir_button.setMaximumSize(QtCore.QSize(100, 30))
self.select_dir_button.setObjectName("pushButton")
self.select_dir_button.clicked.connect(
partial(self.selectfolderpartial, self.select_dir_button))
############################################
# label dir
self.dir_label = QLabel('Folder yang berisi set data citra')
############################################
# button Output
self.output_button = QPushButton('Output')
self.output_button.setMinimumSize(QtCore.QSize(100, 30))
self.output_button.setMaximumSize(QtCore.QSize(100, 30))
self.output_button.setObjectName("pushButton")
self.output_button.clicked.connect(self.saveFileDialog)
############################################
# label Output
self.output_label = QLabel('')
############################################
# button Process
self.process_button = QPushButton('Process')
self.process_button.setMinimumSize(QtCore.QSize(100, 30))
self.process_button.setMaximumSize(QtCore.QSize(100, 30))
self.process_button.setObjectName("pushButton")
self.process_button.clicked.connect(self.process)
############################################
# label Process
self.process_label = QLabel('')
############################################
self.secondLayout.addWidget(self.select_dir_button, 4, 0)
self.secondLayout.addWidget(self.dir_label, 4, 1)
self.secondLayout.addWidget(self.output_button, 5, 0)
self.secondLayout.addWidget(self.output_label, 5, 1)
self.secondLayout.addWidget(self.process_button, 6, 0)
self.secondLayout.addWidget(self.process_label, 6, 1)
def initGlobalVariable(self):
self.height = ''
self.width = ''
self.bin = ''
self.img_path = ''
self.output_string = ''
def setEnabledWidget(self, stat):
self.height_textbox.setEnabled(stat)
self.width_textbox.setEnabled(stat)
self.bin_textbox.setEnabled(stat)
self.select_dir_button.setEnabled(stat)
self.output_button.setEnabled(stat)
self.process_button.setEnabled(stat)
def start(self):
self.setEnabledWidget(False)
self.process_label.setText("Silahkan Tunggu")
def please_done(self):
self.setEnabledWidget(True)
self.process_label.setText("Berhasil")
self.myThread.terminate()
def __init__(self, parent=None):
super(myMblbplayout, self).__init__(parent)
self.fontInit()
self.initMainLayout()
self.initLayout()
self.setMinimumSize(self.mainlayout.sizeHint())
