def _select_next(self, view: W.QListView, sorted_rows: List[int]) -> None:
if not sorted_rows:
return
next_row = sorted_rows[0] - len(sorted_rows) + 1
row_count = view.model().rowCount()
if next_row >= row_count:
next_row = row_count - 1
view.setCurrentIndex(view.model().index(next_row, 0))
def synchronize_selection(self, from_list: QListView, to_list: QListView):
source_selection_model: QItemSelectionModel = from_list.selectionModel()
destination_selection_model: QItemSelectionModel = to_list.selectionModel()
rows = source_selection_model.selectedRows()
if len(rows) > 0:
idx = [r.row() for r in rows]
min_idx, max_idx = min(idx), max(idx)
top_index = QModelIndex(to_list.model().index(min_idx, 0))
bottom_index = QModelIndex(to_list.model().index(max_idx, 0))
destination_selection_model.select(QItemSelection(top_index, bottom_index),
QItemSelectionModel.ClearAndSelect)
def makeTitleStyleBox(self) -> QComboBox:
"""
Create Title Style Drop Down
"""
# ComboBox for title style
self.combo_title_style = QComboBox(self)
view = QListView(self.combo_title_style)
view.setStyleSheet("QListView::item { height : 23 px; }"
"selection-background-color: rgba(0,0,0,0.2);")
self.combo_title_style.setView(view)
self.combo_title_style.setToolTip('Styles')
self.combo_title_style.addItems(self.doc_props.dict_title_styles)
# traverses through combo_title_style items index
for x in range(view.model().rowCount()):
# mods by two to get the index with titles else gives "update" titles index
# changes font to be bold for if and italic for else
if x % 2 == 0:
font = QFont()
font.setWeight(QFont.Bold)
self.combo_title_style.setItemData(x, font, Qt.FontRole)
else:
font = QFont()
color = QBrush()
font.setItalic(True)
color.setColor(QColor("gray"))
self.combo_title_style.setItemData(x, font, Qt.FontRole)
self.combo_title_style.setItemData(x, color, Qt.ForegroundRole)
# adds separators to clean up look of QComboBox
for x in range(2, 23, 3):
size = QSize()
size.setHeight(10)
separator = QStandardItem()
separator.setSizeHint(size)
view.model().insertRow(x, separator)
view.model().item(x).setEnabled(False)
self.combo_title_style.setFocusPolicy(Qt.NoFocus)
self.combo_title_style.setMaxVisibleItems(view.model().rowCount())
self.combo_title_style.setItemData(0, "test", QtCore.Qt.ToolTipRole)
numKey = Qt.Key_1
index = 0
title_list = list(self.doc_props.dict_title_styles.keys())
for key in range(0, 13, 2):
shortcut = QShortcut(QKeySequence(Qt.CTRL + Qt.ALT + numKey), self)
shortcut.activated.connect(
partial(self.titleStyleHelper, title_list[key]))
self.combo_title_style.setItemData(
index, "Ctrl+Alt+" + str(numKey - Qt.Key_1 + 1),
QtCore.Qt.ToolTipRole)
index += 3
numKey += 1
shortcut = QShortcut(QKeySequence(Qt.CTRL + Qt.ALT + Qt.Key_0), self)
shortcut.activated.connect(
partial(self.titleStyleHelper,
self.document.doc_props.text_reset_title))
self.combo_title_style.setItemData(index, "Ctrl+Alt+0",
QtCore.Qt.ToolTipRole)
self.combo_title_style.textActivated.connect(self.titleStyleHelper)
return self.combo_title_style
class DatabaseWidget(QSplitter):
def __init__(self):
super().__init__()
self.setOrientation(Qt.Vertical)
self.create_ui()
def create_ui(self):
top = QWidget()
box = QVBoxLayout()
top.setLayout(box)
box.addWidget(label('<strong>Stored regions</strong>'))
self.listview = QListView()
self.listview.setModel(DatabaseModel(db))
self.listview.selectionModel().selectionChanged.connect(self.selection_changed)
self.listview.doubleClicked.connect(self.list_double_clicked)
self.listview.setEditTriggers(QListView.EditKeyPressed | QListView.SelectedClicked)
box.addWidget(self.listview)
self.addWidget(top)
self.poly = PolyWidget()
self.addWidget(self.poly)
def unselect(self):
selection_model = self.listview.selectionModel()
selection_model.select(QModelIndex(), QItemSelectionModel.SelectCurrent)
def select(self, row):
selection_model = self.listview.selectionModel()
index = self.listview.model().index(row, 0, QModelIndex())
selection_model.select(index, QItemSelectionModel.SelectCurrent)
def selection_changed(self, selected, deselected):
try:
index = selected.indexes()[0]
except IndexError:
main_widget.set_selected()
self.poly.show()
return
poly = db[index.row()]
main_widget.set_selected(poly.lfid)
self.poly.show(poly)
def list_double_clicked(self, item):
main_widget.focus(db[item.row()].lfid)
class QuickAccessWidget(QFrame):
def __init__(self, parent):
QFrame.__init__(self, parent)
self.setFrameStyle(QFrame.Box | QFrame.Sunken)
self.setStyleSheet("QListView {background: transparent; }")
self.setLayout(QHBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.listView = QListView(self)
self.layout().addWidget(self.listView)
self.listView.setModel(self.window().quickAccessModel)
self.listView.setMovement(QListView.Snap)
self.listView.setFlow(QListView.LeftToRight)
self.listView.setResizeMode(QListView.Adjust)
gridSize = self.logicalDpiX() / 96 * 60
self.listView.setGridSize(QSize(gridSize, gridSize))
self.listView.setViewMode(QListView.IconMode)
self.listView.activated.connect(self.listView.model().runShortcut)
class Field_Area_Component():
def __init__(self, proxy_server=Proxy_Server()):
self.proxy_server = proxy_server
self.edited_packet_list = []
self.packet_idx = 0
self.layer_idx = 0
def install_widgets(self, parent=None):
self.list = QListView(parent)
self.list.setModel(self.proxy_server.intercept_queue.field_list_model)
self.model = self.list.model()
self.model.itemChanged.connect(self.on_edit)
self.list.show()
def set_selected_packet(self, pidx, lidx):
self.packet_idx = pidx
self.layer_idx = lidx
def on_edit(self, item):
if ":" not in item.text():
print("ERROR: malformed field. Changes not saved.")
print(
"Please make sure field is in the form '<fieldName>:<value>'.")
return
newField = item.text().split(":")
self.edited_packet_list = copy.deepcopy(
self.proxy_server.intercept_queue.packet_list)
layer = self.edited_packet_list[self.packet_idx].get_layer(
self.layer_idx)
fieldList = self.edited_packet_list[self.packet_idx].fields[layer]
for k, v in fieldList.items():
if (k == newField[0]):
fieldList[k] = newField[1]
self.edited_packet_list[
self.packet_idx].fields[layer] = fieldList
break
class _SpellCheckDialog(Dialog):
def __init__(
self,
api: Api,
main_window: QMainWindow,
spell_checker: BaseSpellChecker,
) -> None:
super().__init__(main_window)
self._main_window = main_window
self._api = api
self._spell_checker = spell_checker
self._lines_to_spellcheck = api.subs.selected_events
self._mispelt_text_edit = QLineEdit(self)
self._mispelt_text_edit.setReadOnly(True)
self._replacement_text_edit = QLineEdit(self)
self._suggestions_list_view = QListView(self)
self._suggestions_list_view.setModel(QStandardItemModel())
self._suggestions_list_view.clicked.connect(self._on_suggestion_click)
box = QWidget(self)
box_layout = QVBoxLayout(box)
box_layout.setContentsMargins(0, 0, 0, 0)
box_layout.addWidget(QLabel("Mispelt word:", self))
box_layout.addWidget(self._mispelt_text_edit)
box_layout.addWidget(QLabel("Replacement:", self))
box_layout.addWidget(self._replacement_text_edit)
box_layout.addWidget(QLabel("Suggestions:", self))
box_layout.addWidget(self._suggestions_list_view)
strip = QDialogButtonBox(self)
strip.setOrientation(Qt.Orientation.Vertical)
self.add_btn = strip.addButton("Add to dictionary", strip.ActionRole)
self.ignore_btn = strip.addButton("Ignore", strip.ActionRole)
self.ignore_all_btn = strip.addButton("Ignore all", strip.ActionRole)
self.replace_btn = strip.addButton("Replace", strip.ActionRole)
strip.addButton("Cancel", strip.RejectRole)
strip.clicked.connect(self.action)
strip.rejected.connect(self.reject)
layout = QHBoxLayout(self)
layout.setSpacing(24)
layout.addWidget(box)
layout.addWidget(strip)
self.setWindowTitle("Spell checker")
@async_slot(QAbstractButton)
async def action(self, sender: QAbstractButton) -> None:
if sender == self.replace_btn:
await self._replace()
elif sender == self.add_btn:
await self._add_to_dictionary()
elif sender == self.ignore_btn:
await self._ignore()
elif sender == self.ignore_all_btn:
await self._ignore_all()
@property
def text_edit(self) -> QWidget:
return cast(QWidget,
self._main_window.findChild(QWidget, "text-editor"))
async def _replace(self) -> None:
text = self.text_edit.toPlainText()
text = (text[:self.text_edit.textCursor().selectionStart()] +
self._replacement_text_edit.text() +
text[self.text_edit.textCursor().selectionEnd():])
self.text_edit.document().setPlainText(text)
await self.next()
async def _add_to_dictionary(self) -> None:
self._spell_checker.add(self._mispelt_text_edit.text())
await self.next()
async def _ignore(self) -> None:
await self.next()
async def _ignore_all(self) -> None:
self._spell_checker.add_to_session(self._mispelt_text_edit.text())
await self.next()
async def next(self) -> bool:
ret = self._iter_to_next_mispelt_match()
if ret is None:
await show_notice("No more results.", self)
self.reject()
return False
idx, start, end, word = ret
self._focus_match(idx, start, end, word)
return True
def _iter_to_next_mispelt_match(
self, ) -> Optional[tuple[int, int, int, str]]:
cursor = self.text_edit.textCursor()
while self._lines_to_spellcheck:
line = self._lines_to_spellcheck[0]
for start, end, word in spell_check_ass_line(
self._spell_checker, line.text.replace("\\N", "\n")):
if (len(self._api.subs.selected_indexes) > 1
or line.index > self._api.subs.selected_indexes[0]
or start > cursor.selectionStart()
or cursor.selectionStart() == cursor.selectionEnd()):
return line.index, start, end, word
self._lines_to_spellcheck.pop(0)
return None
def _focus_match(self, idx: int, start: int, end: int,
mispelt_word: str) -> None:
self._api.subs.selected_indexes = [idx]
cursor = self.text_edit.textCursor()
cursor.setPosition(start)
cursor.setPosition(end, QTextCursor.KeepAnchor)
self.text_edit.setTextCursor(cursor)
self._mispelt_text_edit.setText(mispelt_word)
self._suggestions_list_view.model().clear()
for suggestion in self._spell_checker.suggest(mispelt_word):
item = QStandardItem(suggestion)
item.setEditable(False)
self._suggestions_list_view.model().appendRow(item)
def _on_suggestion_click(self, index: QModelIndex) -> None:
self._replacement_text_edit.setText(index.data())
class OS2Tab(TabWidget):
def __init__(self, font, parent=None):
super().__init__(parent, name="OS/2")
# OS2Group = QGroupBox("OS/2 table", self)
# OS2Group.setFlat(True)
OS2Layout = QGridLayout(self)
usWidthClassLabel = QLabel("usWidthClass:", self)
self.usWidthClassDrop = QComboBox(self)
items = [
"None", "Ultra-condensed", "Extra-condensed", "Condensed",
"Semi-Condensed", "Medium (normal)", "Semi-expanded", "Expanded",
"Extra-expanded", "Ultra-expanded"]
self.usWidthClassDrop.insertItems(0, items)
if font.info.openTypeOS2WidthClass is not None:
self.usWidthClassDrop.setCurrentIndex(
font.info.openTypeOS2WidthClass)
fsSelectionLabel = QLabel("fsSelection:", self)
fsSelection = font.info.openTypeOS2Selection
self.fsSelectionList = QListView(self)
items = [
"1 UNDERSCORE", "2 NEGATIVE", "3 OUTLINED", "4 STRIKEOUT",
"7 USE_TYPO_METRICS", "8 WWS", "9 OBLIQUE"]
# http://stackoverflow.com/a/26613163
model = QStandardItemModel(7, 1)
for index, elem in enumerate(items):
item = QStandardItem()
item.setText(elem)
item.setCheckable(True)
bit = index + 1
if fsSelection is not None and bit in fsSelection:
# maybe default setting? if so, unneeded
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
model.setItem(index, item)
self.fsSelectionList.setModel(model)
achVendorIDLabel = QLabel("achVendorID:", self)
self.achVendorIDEdit = QLineEdit(font.info.openTypeOS2VendorID, self)
self.achVendorIDEdit.setMaxLength(4)
fsTypeLabel = QLabel("fsType:", self)
fsType = font.info.openTypeOS2Type
self.fsTypeDrop = QComboBox(self)
items = [
"No embedding restrictions", "Restricted embedding",
"Preview and print embedding allowed",
"Editable embedding allowed"]
self.allowSubsettingBox = QCheckBox("Allow subsetting", self)
self.allowBitmapEmbeddingBox = QCheckBox(
"Allow only bitmap embedding", self)
self.fsTypeDrop.currentIndexChanged[int].connect(
self._updateFsTypeVisibility)
self.fsTypeDrop.insertItems(0, items)
if fsType is not None:
for i in range(1, 4):
if i in fsType:
self.fsTypeDrop.setCurrentIndex(i)
break
self.allowSubsettingBox.setChecked(8 not in fsType)
self.allowBitmapEmbeddingBox.setChecked(9 in fsType)
# XXX: ulUnicodeRange
# XXX: ulCodePageRange
sTypoAscenderLabel = QLabel("sTypoAscender:", self)
sTypoDescenderLabel = QLabel("sTypoDescender:", self)
sTypoLineGapLabel = QLabel("sTypoLineGap:", self)
usWeightClassLabel = QLabel("usWeightClass:", self)
usWinAscentLabel = QLabel("usWinAscent:", self)
usWinDescentLabel = QLabel("usWinDescent:", self)
ySubscriptXSizeLabel = QLabel("ySubscriptXSize:", self)
ySubscriptYSizeLabel = QLabel("ySubscriptYSize:", self)
ySubscriptXOffsetLabel = QLabel("ySubscriptXOffset:", self)
ySubscriptYOffsetLabel = QLabel("ySubscriptYOffset:", self)
ySuperscriptXSizeLabel = QLabel("ySuperscriptXSize:", self)
ySuperscriptYSizeLabel = QLabel("ySuperscriptYSize:", self)
ySuperscriptXOffsetLabel = QLabel("ySuperscriptXOffset:", self)
ySuperscriptYOffsetLabel = QLabel("ySuperscriptYOffset:", self)
yStrikeoutSizeLabel = QLabel("yStrikeoutSize:", self)
yStrikeoutPositionLabel = QLabel("yStrikeoutPosition:", self)
self.loadPositiveInteger(
font, "openTypeOS2WeightClass", "usWeightClass")
self.loadInteger(font, "openTypeOS2TypoAscender", "sTypoAscender")
self.loadInteger(font, "openTypeOS2TypoDescender", "sTypoDescender")
self.loadInteger(font, "openTypeOS2TypoLineGap", "sTypoLineGap")
self.loadPositiveInteger(font, "openTypeOS2WinAscent", "usWinAscent")
self.loadPositiveInteger(font, "openTypeOS2WinDescent", "usWinDescent")
self.loadInteger(font, "openTypeOS2SubscriptXSize", "ySubscriptXSize")
self.loadInteger(font, "openTypeOS2SubscriptYSize", "ySubscriptYSize")
self.loadInteger(
font, "openTypeOS2SubscriptXOffset", "ySubscriptXOffset")
self.loadInteger(
font, "openTypeOS2SubscriptYOffset", "ySubscriptYOffset")
self.loadInteger(
font, "openTypeOS2SuperscriptXSize", "ySuperscriptXSize")
self.loadInteger(
font, "openTypeOS2SuperscriptYSize", "ySuperscriptYSize")
self.loadInteger(
font, "openTypeOS2SuperscriptXOffset", "ySuperscriptXOffset")
self.loadInteger(
font, "openTypeOS2SuperscriptYOffset", "ySuperscriptYOffset")
self.loadInteger(font, "openTypeOS2StrikeoutSize", "yStrikeoutSize")
self.loadInteger(
font, "openTypeOS2StrikeoutPosition", "yStrikeoutPosition")
# XXX: panose
l = 0
OS2Layout.addWidget(usWidthClassLabel, l, 0)
OS2Layout.addWidget(self.usWidthClassDrop, l, 1, 1, 2)
OS2Layout.addWidget(achVendorIDLabel, l, 3)
OS2Layout.addWidget(self.achVendorIDEdit, l, 4, 1, 2)
l += 1
OS2Layout.addWidget(usWeightClassLabel, l, 0)
OS2Layout.addWidget(self.usWeightClassEdit, l, 1, 1, 2)
l += 1
OS2Layout.addWidget(fsSelectionLabel, l, 0, 3, 1)
OS2Layout.addWidget(self.fsSelectionList, l, 1, 3, 2)
OS2Layout.addWidget(fsTypeLabel, l, 3, 3, 1)
OS2Layout.addWidget(self.fsTypeDrop, l, 4, 1, 2)
l += 1
OS2Layout.addWidget(self.allowSubsettingBox, l, 4, 1, 2)
l += 1
OS2Layout.addWidget(self.allowBitmapEmbeddingBox, l, 4, 1, 2)
l += 1
OS2Layout.addWidget(sTypoAscenderLabel, l, 0)
OS2Layout.addWidget(self.sTypoAscenderEdit, l, 1, 1, 2)
OS2Layout.addWidget(usWinAscentLabel, l, 3)
OS2Layout.addWidget(self.usWinAscentEdit, l, 4, 1, 2)
l += 1
OS2Layout.addWidget(sTypoDescenderLabel, l, 0)
OS2Layout.addWidget(self.sTypoDescenderEdit, l, 1, 1, 2)
OS2Layout.addWidget(usWinDescentLabel, l, 3)
OS2Layout.addWidget(self.usWinDescentEdit, l, 4, 1, 2)
l += 1
OS2Layout.addWidget(sTypoLineGapLabel, l, 0)
OS2Layout.addWidget(self.sTypoLineGapEdit, l, 1, 1, 2)
l += 1
OS2Layout.addWidget(ySubscriptXSizeLabel, l, 0)
OS2Layout.addWidget(self.ySubscriptXSizeEdit, l, 1, 1, 2)
OS2Layout.addWidget(ySubscriptXOffsetLabel, l, 3)
OS2Layout.addWidget(self.ySubscriptXOffsetEdit, l, 4, 1, 2)
l += 1
OS2Layout.addWidget(ySubscriptYSizeLabel, l, 0)
OS2Layout.addWidget(self.ySubscriptYSizeEdit, l, 1, 1, 2)
OS2Layout.addWidget(ySubscriptYOffsetLabel, l, 3)
OS2Layout.addWidget(self.ySubscriptYOffsetEdit, l, 4, 1, 2)
l += 1
OS2Layout.addWidget(ySuperscriptXSizeLabel, l, 0)
OS2Layout.addWidget(self.ySuperscriptXSizeEdit, l, 1, 1, 2)
OS2Layout.addWidget(ySuperscriptXOffsetLabel, l, 3)
OS2Layout.addWidget(self.ySuperscriptXOffsetEdit, l, 4, 1, 2)
l += 1
OS2Layout.addWidget(ySuperscriptYSizeLabel, l, 0)
OS2Layout.addWidget(self.ySuperscriptYSizeEdit, l, 1, 1, 2)
OS2Layout.addWidget(ySuperscriptYOffsetLabel, l, 3)
OS2Layout.addWidget(self.ySuperscriptYOffsetEdit, l, 4, 1, 2)
l += 1
OS2Layout.addWidget(yStrikeoutSizeLabel, l, 0)
OS2Layout.addWidget(self.yStrikeoutSizeEdit, l, 1, 1, 2)
OS2Layout.addWidget(yStrikeoutPositionLabel, l, 3)
OS2Layout.addWidget(self.yStrikeoutPositionEdit, l, 4, 1, 2)
# OS2Group.setLayout(OS2Layout)
self.setLayout(OS2Layout)
def _updateFsTypeVisibility(self, index):
if index == 0:
# TODO: maybe uncheck as well?
self.allowSubsettingBox.setEnabled(False)
self.allowBitmapEmbeddingBox.setEnabled(False)
else:
self.allowSubsettingBox.setEnabled(True)
self.allowBitmapEmbeddingBox.setEnabled(True)
def writeValues(self, font):
self.writePositiveInteger(
font, "usWeightClass", "openTypeOS2WeightClass")
self.writeInteger(font, "sTypoAscender", "openTypeOS2TypoAscender")
self.writeInteger(font, "sTypoDescender", "openTypeOS2TypoDescender")
self.writeInteger(font, "sTypoLineGap", "openTypeOS2TypoLineGap")
self.writePositiveInteger(font, "usWinAscent", "openTypeOS2WinAscent")
self.writePositiveInteger(
font, "usWinDescent", "openTypeOS2WinDescent")
self.writeInteger(font, "ySubscriptXSize", "openTypeOS2SubscriptXSize")
self.writeInteger(font, "ySubscriptYSize", "openTypeOS2SubscriptYSize")
self.writeInteger(
font, "ySubscriptXOffset", "openTypeOS2SubscriptXOffset")
self.writeInteger(
font, "ySubscriptYOffset", "openTypeOS2SubscriptYOffset")
self.writeInteger(
font, "ySuperscriptXSize", "openTypeOS2SuperscriptXSize")
self.writeInteger(
font, "ySuperscriptYSize", "openTypeOS2SuperscriptYSize")
self.writeInteger(
font, "ySuperscriptXOffset", "openTypeOS2SuperscriptXOffset")
self.writeInteger(
font, "ySuperscriptYOffset", "openTypeOS2SuperscriptYOffset")
self.writeInteger(font, "yStrikeoutSize", "openTypeOS2StrikeoutSize")
self.writeInteger(
font, "yStrikeoutPosition", "openTypeOS2StrikeoutPosition")
fsSelectionModel = self.fsSelectionList.model()
fsSelection = []
for i in range(7):
item = fsSelectionModel.item(i)
if item.checkState() == Qt.Checked:
fsSelection.append(i)
if len(fsSelection):
font.info.openTypeOS2Selection = fsSelection
else:
# XXX: None or empty array? should distinct those cases
font.info.openTypeOS2Selection = None
fsTypeIndex = self.fsTypeDrop.currentIndex()
fsType = []
if fsTypeIndex > 0:
fsType.append(fsTypeIndex)
if not self.allowSubsettingBox.isChecked():
fsType.append(8)
if self.allowBitmapEmbeddingBox.isChecked():
fsType.append(9)
# TODO: provide a way to represent None w this?
font.info.openTypeOS2Type = fsType
# TODO: see if data needs to be padded to 4 chars.
# I think that this is to be deferred to ufo2fdk(?)
font.info.openTypeOS2VendorID = self.achVendorIDEdit.text()
class ColorMapsDialog(object):
def __init__(self, title, message, items_selected, imageName):
self.title = title
self.message = message
self.items_selected = items_selected #[s for s in items_selected.split(',')]
self.imageName = imageName
self.cmObj = ColorMaps()
self.CM = self.cmObj.colorMaps
form = QFormLayout()
form.addRow(QLabel(message))
self.listView = QListView()
form.addRow(self.listView)
font = QFont()
font.setBold(True)
font.setPointSize(8)
self.listView.setFont(font)
model = QStandardItemModel(self.listView)
size = QSize(60,30)
for item in self.CM:
# create an item with a caption
standardItem = QStandardItem(item)
standardItem.setCheckable(True)
if item in self.items_selected: standardItem.setCheckState(True)
standardItem.setSizeHint(size)
model.appendRow(standardItem)
self.listView.setModel(model)
def setupUi(self, Dialog):
Dialog.setObjectName("Dialog")
Dialog.resize(530, 447)
Dialog.setWindowTitle(self.title)
self.buttonBox = QDialogButtonBox(Dialog)
self.buttonBox.setGeometry(QRect(10, 390, 511, 32))
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel|QDialogButtonBox.Ok)
self.buttonBox.setObjectName("buttonBox")
self.horizontalLayoutWidget = QWidget(Dialog)
self.horizontalLayoutWidget.setGeometry(QRect(9, 10, 511, 363))
self.horizontalLayoutWidget.setObjectName("horizontalLayoutWidget")
self.horizontalLayout = QHBoxLayout(self.horizontalLayoutWidget)
self.horizontalLayout.setContentsMargins(0, 0, 0, 0)
self.horizontalLayout.setObjectName("horizontalLayout")
self.horizontalLayout.addWidget(self.listView)
self.label = QLabel(self.horizontalLayoutWidget)
self.label.setText("")
self.label.setPixmap(QPixmap(self.imageName))
self.label.setAlignment(Qt.AlignCenter)
self.label.setObjectName("label")
self.horizontalLayout.addWidget(self.label)
self.retranslateUi(Dialog)
self.buttonBox.accepted.connect(Dialog.accept)
self.buttonBox.rejected.connect(Dialog.reject)
QMetaObject.connectSlotsByName(Dialog)
def retranslateUi(self, Dialog):
_translate = QCoreApplication.translate
Dialog.setWindowTitle(_translate("Dialog", self.title))
def itemsSelected(self):
selected = []
model = self.listView.model()
i = 0
while model.item(i):
if model.item(i).checkState():
selected.append(model.item(i).text())
i += 1
return selected
class ErrorVisualizeWidget(QWidget):
def __init__(self, parent, mainwindow):
super().__init__(parent)
self.__widget_mainwindow = mainwindow
self.__widget_matplotlib = ErrorVisualizeMatplotlibWidget(self)
self.__current_layer = 0
self.__widget_label_wrong_dimension = QLabel("", parent=self)
self.__widget_label_layer = QLabel("<b>Layer</b>: ", parent=self)
self.__widget_list_layer = QListView(self)
self.__widget_list_layer.setModel(QStandardItemModel())
self.__widget_list_layer.clicked.connect(self.set_layer)
self.__widget_list_layer.selectionModel().selectionChanged.connect(self.set_layer)
if not SDB_HAS_MATPLOTLIB:
self.__widget_label_layer.setEnabled(False)
self.__widget_list_layer.setEnabled(False)
hbox_top = QHBoxLayout()
hbox_top.addWidget(self.__widget_matplotlib)
vbox_top = QVBoxLayout()
vbox_top.addWidget(self.__widget_label_layer)
vbox_top.addWidget(self.__widget_list_layer)
hbox_top.addLayout(vbox_top)
hbox_bottom = QHBoxLayout()
hbox_bottom.addWidget(self.__widget_label_wrong_dimension)
hbox_bottom.addStretch(1)
vbox = QVBoxLayout()
vbox.addLayout(hbox_top)
vbox.addLayout(hbox_bottom)
self.setLayout(vbox)
def make_update(self, comparison_result):
Logger.info("Updating ErrorVisualizeWidget")
if not SDB_HAS_MATPLOTLIB:
return
self.__error_positions = comparison_result.get_error_positions()
if self.__error_positions.ndim in (2, 3):
self.__current_layer = 0
self.__widget_matplotlib.draw_layer(self.__error_positions, self.__current_layer)
self.__widget_list_layer.model().clear()
if self.__error_positions.ndim == 3:
self.__widget_label_layer.setEnabled(True)
self.__widget_list_layer.setEnabled(True)
for k in range(self.__error_positions.shape[2]):
item = QStandardItem(" %i" % k)
if any(self.__error_positions[:, :, k]):
item.setIcon(Icon("failure-small.png"))
else:
item.setIcon(Icon("success.png"))
item.setEditable(False)
self.__widget_list_layer.model().insertRow(k, item)
else:
self.__widget_label_layer.setEnabled(False)
self.__widget_list_layer.setEnabled(False)
self.__widget_label_wrong_dimension.setText("")
else:
self.__widget_matplotlib.draw_nothing()
self.__widget_label_layer.setEnabled(False)
self.__widget_list_layer.model().clear()
self.__widget_list_layer.setEnabled(False)
self.__widget_label_wrong_dimension.setText(
"Visualization is only supported for 2 and 3-dimensional fields.")
def set_layer(self, layer):
if isinstance(layer, QItemSelection):
layer = layer.indexes()[0]
layer_idx = layer.row()
self.__current_layer = layer_idx
self.__widget_matplotlib.draw_layer(self.__error_positions, self.__current_layer)
class Settings(QWidget):
def __init__(self, main):
# init
QWidget.__init__(self)
self.main = main
self.lang = main.lang
# setup window
self.setWindowIcon(QIcon(SETTINGS))
self.setWindowTitle(self.lang['settings_title'])
self.resize(500, 460)
# setup vars
self._palette = QPalette()
self._palette.setColor(QPalette.WindowText,
main._palette.color(QPalette.WindowText))
# setup update label
self.update_label = QLabel(self.lang['update_label'], self)
self.update_label.setToolTip(self.lang['update_label_tt'])
# setup update spinbox
self.update_spinbox = QSpinBox(self)
self.update_spinbox.setToolTip(self.lang['update_spinbox_tt'])
self.update_spinbox.setMinimum(500)
self.update_spinbox.setMaximum(86400000)
self.update_spinbox.setValue(main._update)
# setup round label
self.round_label = QLabel(self.lang['round_label'], self)
self.round_label.setToolTip(self.lang['round_label_tt'])
# setup round spinbox
self.round_spinbox = QSpinBox(self)
self.round_spinbox.setToolTip(self.lang['round_spinbox_tt'])
self.round_spinbox.setMinimum(1)
self.round_spinbox.setMaximum(100)
self.round_spinbox.setValue(main._round)
# setup font size spinbox
self.size_spinbox = QSpinBox()
self.size_spinbox.setToolTip(self.lang['size_spinbox_tt'])
self.size_spinbox.setMinimum(8)
self.size_spinbox.setMaximum(80)
self.size_spinbox.setValue(main._font.pointSize())
# setup labels checkbox
self.labels_checkbox = QCheckBox(self.lang['labels_checkbox'], self)
self.labels_checkbox.setToolTip(self.lang['labels_checkbox_tt'])
self.labels_checkbox.setChecked(main._labels)
# setup pername checkbox
self.pername_checkbox = QCheckBox(self.lang['pername_checkbox'], self)
self.pername_checkbox.setToolTip(self.lang['pername_checkbox_tt'])
self.pername_checkbox.setChecked(main._pername)
# setup bar checkbox
self.bar_checkbox = QCheckBox(self.lang['bar_checkbox'], self)
self.bar_checkbox.setToolTip(self.lang['bar_checkbox_tt'])
self.bar_checkbox.setChecked(main._bar)
# setup text checkbox
self.text_checkbox = QCheckBox(self.lang['text_checkbox'], self)
self.text_checkbox.setToolTip(self.lang['text_checkbox_tt'])
self.text_checkbox.setChecked(main._text)
# setup srecv checkbox
self.srecv_checkbox = QCheckBox(self.lang['srecv_checkbox'], self)
self.srecv_checkbox.setToolTip(self.lang['srecv_checkbox_tt'])
self.srecv_checkbox.setChecked(main._srecv)
# setup ssent checkbox
self.ssent_checkbox = QCheckBox(self.lang['ssent_checkbox'], self)
self.ssent_checkbox.setToolTip(self.lang['ssent_checkbox_tt'])
self.ssent_checkbox.setChecked(main._ssent)
# setup trecv checkbox
self.trecv_checkbox = QCheckBox(self.lang['trecv_checkbox'], self)
self.trecv_checkbox.setToolTip(self.lang['trecv_checkbox_tt'])
self.trecv_checkbox.setChecked(main._trecv)
# setup tsent checkbox
self.tsent_checkbox = QCheckBox(self.lang['tsent_checkbox'], self)
self.tsent_checkbox.setToolTip(self.lang['tsent_checkbox_tt'])
self.tsent_checkbox.setChecked(main._tsent)
# setup precv checkbox
self.precv_checkbox = QCheckBox(self.lang['precv_checkbox'], self)
self.precv_checkbox.setToolTip(self.lang['precv_checkbox_tt'])
self.precv_checkbox.setChecked(main._precv)
# setup psent checkbox
self.psent_checkbox = QCheckBox(self.lang['psent_checkbox'], self)
self.psent_checkbox.setToolTip(self.lang['psent_checkbox_tt'])
self.psent_checkbox.setChecked(main._psent)
# setup errin checkbox
self.errin_checkbox = QCheckBox(self.lang['errin_checkbox'], self)
self.errin_checkbox.setToolTip(self.lang['errin_checkbox_tt'])
self.errin_checkbox.setChecked(main._errin)
# setup errout checkbox
self.errout_checkbox = QCheckBox(self.lang['errout_checkbox'], self)
self.errout_checkbox.setToolTip(self.lang['errout_checkbox_tt'])
self.errout_checkbox.setChecked(main._errout)
# setup dropin checkbox
self.dropin_checkbox = QCheckBox(self.lang['dropin_checkbox'], self)
self.dropin_checkbox.setToolTip(self.lang['dropin_checkbox_tt'])
self.dropin_checkbox.setChecked(main._dropin)
# setup dropout checkbox
self.dropout_checkbox = QCheckBox(self.lang['dropout_checkbox'], self)
self.dropout_checkbox.setToolTip(self.lang['dropout_checkbox_tt'])
self.dropout_checkbox.setChecked(main._dropout)
# setup connection checkbox
self.con_checkbox = QCheckBox(self.lang['con_checkbox'], self)
self.con_checkbox.setToolTip(self.lang['con_checkbox_tt'])
self.con_checkbox.setChecked(main._con)
# setup bold checkbox
self.bold_checkbox = QCheckBox(self.lang['bold_checkbox'], self)
self.bold_checkbox.setToolTip(self.lang['bold_checkbox_tt'])
self.bold_checkbox.setChecked(main._font.bold())
# setup kind cbox combobox
self.kind_cbox = QComboBox(self)
self.kind_cbox.setToolTip(self.lang['kind_cbox_tt'])
self.kind_cbox.addItems(('inet', 'inet4', 'inet6', 'tcp', 'tcp4',
'tcp6', 'udp', 'udp4', 'udp6', 'unix', 'all'))
self.kind_cbox.setCurrentText(main._kind)
# setup ifaces list view
self.ifaces_list = QListView(self)
self.ifaces_list.setToolTip(self.lang['ifaces_list_tt'])
self.stats = psutil.net_if_stats()
ifaces_model = QStandardItemModel(len(self.stats), 1)
i = 0
for name in self.stats:
item = QStandardItem(name)
item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
if name in main._names:
item.setData(Qt.Checked, Qt.CheckStateRole)
else:
item.setData(Qt.Unchecked, Qt.CheckStateRole)
ifaces_model.setItem(i, 0, item)
i += 1
self.ifaces_list.setModel(ifaces_model)
# setup color button
self.color_button = QPushButton(self.lang['color_button'], self)
self.color_button.setToolTip(self.lang['color_button_tt'])
self.color_button.clicked.connect(self._color)
# setup save button
self.save_button = QPushButton(self.lang['save_button'], self)
self.save_button.setToolTip(self.lang['save_button_tt'])
self.save_button.clicked.connect(self._save)
# setup cancel button
self.cancel_button = QPushButton(self.lang['cancel_button'], self)
self.cancel_button.setToolTip(self.lang['cancel_button_tt'])
self.cancel_button.clicked.connect(self.close)
# setup font settings h box layout
self.h_box2 = QHBoxLayout()
self.h_box2.addWidget(self.size_spinbox)
self.h_box2.addWidget(self.bold_checkbox)
# setup buttons h box layout
self.h_box = QHBoxLayout()
self.h_box.addWidget(self.save_button)
self.h_box.addWidget(self.cancel_button)
# setup layout
self.grid = QGridLayout(self)
self.grid.addWidget(self.update_label, 0, 0)
self.grid.addWidget(self.update_spinbox, 0, 1)
self.grid.addWidget(self.round_label, 1, 0)
self.grid.addWidget(self.round_spinbox, 1, 1)
self.grid.addWidget(self.labels_checkbox, 2, 0)
self.grid.addWidget(self.pername_checkbox, 2, 1)
self.grid.addWidget(self.bar_checkbox, 3, 0)
self.grid.addWidget(self.text_checkbox, 3, 1)
self.grid.addWidget(self.srecv_checkbox, 4, 0)
self.grid.addWidget(self.ssent_checkbox, 4, 1)
self.grid.addWidget(self.trecv_checkbox, 5, 0)
self.grid.addWidget(self.tsent_checkbox, 5, 1)
self.grid.addWidget(self.precv_checkbox, 6, 0)
self.grid.addWidget(self.psent_checkbox, 6, 1)
self.grid.addWidget(self.errin_checkbox, 7, 0)
self.grid.addWidget(self.errout_checkbox, 7, 1)
self.grid.addWidget(self.dropin_checkbox, 8, 0)
self.grid.addWidget(self.dropout_checkbox, 8, 1)
self.grid.addWidget(self.con_checkbox, 9, 0)
self.grid.addWidget(self.kind_cbox, 10, 0)
self.grid.addWidget(self.ifaces_list, 10, 1)
self.grid.addWidget(self.color_button, 11, 0)
self.grid.addLayout(self.h_box2, 11, 1)
self.grid.addLayout(self.h_box, 12, 0, 1, 2)
self.setLayout(self.grid)
# show
self.show()
@try_except()
def _color(self, checked):
self._palette.setColor(
QPalette.WindowText,
QColorDialog.getColor(self._palette.color(QPalette.WindowText),
self, self.lang['color_title']))
@try_except()
def _save(self, checked):
self.main._update = self.update_spinbox.value()
self.main._round = self.round_spinbox.value()
self.main._labels = self.labels_checkbox.isChecked()
self.main._pername = self.pername_checkbox.isChecked()
self.main._bar = self.bar_checkbox.isChecked()
self.main._text = self.text_checkbox.isChecked()
self.main._srecv = self.srecv_checkbox.isChecked()
self.main._ssent = self.ssent_checkbox.isChecked()
self.main._trecv = self.trecv_checkbox.isChecked()
self.main._tsent = self.tsent_checkbox.isChecked()
self.main._precv = self.precv_checkbox.isChecked()
self.main._psent = self.psent_checkbox.isChecked()
self.main._errin = self.errin_checkbox.isChecked()
self.main._errout = self.errout_checkbox.isChecked()
self.main._dropin = self.dropin_checkbox.isChecked()
self.main._dropout = self.dropout_checkbox.isChecked()
self.main._con = self.con_checkbox.isChecked()
self.main._kind = self.kind_cbox.currentText()
self.main._palette = self._palette
self.main._font.setPointSize(self.size_spinbox.value())
self.main._font.setBold(self.bold_checkbox.isChecked())
names = []
i = 0
for name in self.stats:
ind = self.ifaces_list.model().index(i, 0)
if self.ifaces_list.model().data(ind, Qt.CheckStateRole):
names.append(name)
i += 1
self.main._names = names
self.main.save_settings()
self.main.timer.stop()
self.main.timer.start(self.main._update)
self.close()
class OS2Tab(TabWidget):
def __init__(self, font, parent=None):
super().__init__(parent)
self.name = self.tr("OS/2")
# OS2Group = QGroupBox("OS/2 table", self)
# OS2Group.setFlat(True)
OS2Layout = QGridLayout(self)
usWidthClassLabel = RLabel(self.tr("usWidthClass:"), self)
self.usWidthClassDrop = QComboBox(self)
items = [
self.tr("None"),
self.tr("Ultra-condensed"),
self.tr("Extra-condensed"),
self.tr("Condensed"),
self.tr("Semi-Condensed"),
self.tr("Medium (normal)"),
self.tr("Semi-expanded"),
self.tr("Expanded"),
self.tr("Extra-expanded"),
self.tr("Ultra-expanded")
]
self.usWidthClassDrop.insertItems(0, items)
if font.info.openTypeOS2WidthClass is not None:
self.usWidthClassDrop.setCurrentIndex(
font.info.openTypeOS2WidthClass)
fsSelectionLabel = RLabel(self.tr("fsSelection:"), self)
fsSelection = font.info.openTypeOS2Selection
self.fsSelectionList = QListView(self)
items = [
"1 UNDERSCORE", "2 NEGATIVE", "3 OUTLINED", "4 STRIKEOUT",
"7 USE_TYPO_METRICS", "8 WWS", "9 OBLIQUE"
]
# http://stackoverflow.com/a/26613163
model = QStandardItemModel(7, 1)
for index, elem in enumerate(items):
item = QStandardItem()
item.setText(elem)
item.setCheckable(True)
bit = index + 1
if fsSelection is not None and bit in fsSelection:
# maybe default setting? if so, unneeded
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
model.setItem(index, item)
self.fsSelectionList.setModel(model)
achVendorIDLabel = RLabel(self.tr("achVendorID:"), self)
self.achVendorIDEdit = QLineEdit(font.info.openTypeOS2VendorID, self)
self.achVendorIDEdit.setMaxLength(4)
fsTypeLabel = RLabel(self.tr("fsType:"), self)
fsType = font.info.openTypeOS2Type
self.fsTypeDrop = QComboBox(self)
items = [
self.tr("No embedding restrictions"),
self.tr("Restricted embedding"),
self.tr("Preview and print embedding allowed"),
self.tr("Editable embedding allowed")
]
self.allowSubsettingBox = QCheckBox(self.tr("Allow subsetting"), self)
self.allowBitmapEmbeddingBox = QCheckBox(
self.tr("Allow only bitmap embedding"), self)
self.fsTypeDrop.currentIndexChanged[int].connect(
self._updateFsTypeVisibility)
self.fsTypeDrop.insertItems(0, items)
if fsType is not None:
for i in range(1, 4):
if i in fsType:
self.fsTypeDrop.setCurrentIndex(i)
break
self.allowSubsettingBox.setChecked(8 not in fsType)
self.allowBitmapEmbeddingBox.setChecked(9 in fsType)
# XXX: ulUnicodeRange
# XXX: ulCodePageRange
sTypoAscenderLabel = RLabel(self.tr("sTypoAscender:"), self)
sTypoDescenderLabel = RLabel(self.tr("sTypoDescender:"), self)
sTypoLineGapLabel = RLabel(self.tr("sTypoLineGap:"), self)
usWeightClassLabel = RLabel(self.tr("usWeightClass:"), self)
usWinAscentLabel = RLabel(self.tr("usWinAscent:"), self)
usWinDescentLabel = RLabel(self.tr("usWinDescent:"), self)
ySubscriptXSizeLabel = RLabel(self.tr("ySubscriptXSize:"), self)
ySubscriptYSizeLabel = RLabel(self.tr("ySubscriptYSize:"), self)
ySubscriptXOffsetLabel = RLabel(self.tr("ySubscriptXOffset:"), self)
ySubscriptYOffsetLabel = RLabel(self.tr("ySubscriptYOffset:"), self)
ySuperscriptXSizeLabel = RLabel(self.tr("ySuperscriptXSize:"), self)
ySuperscriptYSizeLabel = RLabel(self.tr("ySuperscriptYSize:"), self)
ySuperscriptXOffsetLabel = RLabel(self.tr("ySuperscriptXOffset:"),
self)
ySuperscriptYOffsetLabel = RLabel(self.tr("ySuperscriptYOffset:"),
self)
yStrikeoutSizeLabel = RLabel(self.tr("yStrikeoutSize:"), self)
yStrikeoutPositionLabel = RLabel(self.tr("yStrikeoutPosition:"), self)
self.loadPositiveInteger(font, "openTypeOS2WeightClass",
"usWeightClass")
self.loadInteger(font, "openTypeOS2TypoAscender", "sTypoAscender")
self.loadInteger(font, "openTypeOS2TypoDescender", "sTypoDescender")
self.loadInteger(font, "openTypeOS2TypoLineGap", "sTypoLineGap")
self.loadPositiveInteger(font, "openTypeOS2WinAscent", "usWinAscent")
self.loadPositiveInteger(font, "openTypeOS2WinDescent", "usWinDescent")
self.loadInteger(font, "openTypeOS2SubscriptXSize", "ySubscriptXSize")
self.loadInteger(font, "openTypeOS2SubscriptYSize", "ySubscriptYSize")
self.loadInteger(font, "openTypeOS2SubscriptXOffset",
"ySubscriptXOffset")
self.loadInteger(font, "openTypeOS2SubscriptYOffset",
"ySubscriptYOffset")
self.loadInteger(font, "openTypeOS2SuperscriptXSize",
"ySuperscriptXSize")
self.loadInteger(font, "openTypeOS2SuperscriptYSize",
"ySuperscriptYSize")
self.loadInteger(font, "openTypeOS2SuperscriptXOffset",
"ySuperscriptXOffset")
self.loadInteger(font, "openTypeOS2SuperscriptYOffset",
"ySuperscriptYOffset")
self.loadInteger(font, "openTypeOS2StrikeoutSize", "yStrikeoutSize")
self.loadInteger(font, "openTypeOS2StrikeoutPosition",
"yStrikeoutPosition")
# XXX: panose
l = 0
OS2Layout.addWidget(usWidthClassLabel, l, 0)
OS2Layout.addWidget(self.usWidthClassDrop, l, 1, 1, 2)
OS2Layout.addWidget(achVendorIDLabel, l, 3)
OS2Layout.addWidget(self.achVendorIDEdit, l, 4, 1, 2)
l += 1
OS2Layout.addWidget(usWeightClassLabel, l, 0)
OS2Layout.addWidget(self.usWeightClassEdit, l, 1, 1, 2)
l += 1
OS2Layout.addWidget(fsSelectionLabel, l, 0, 3, 1)
OS2Layout.addWidget(self.fsSelectionList, l, 1, 3, 2)
OS2Layout.addWidget(fsTypeLabel, l, 3, 3, 1)
OS2Layout.addWidget(self.fsTypeDrop, l, 4, 1, 2)
l += 1
OS2Layout.addWidget(self.allowSubsettingBox, l, 4, 1, 2)
l += 1
OS2Layout.addWidget(self.allowBitmapEmbeddingBox, l, 4, 1, 2)
l += 1
OS2Layout.addWidget(sTypoAscenderLabel, l, 0)
OS2Layout.addWidget(self.sTypoAscenderEdit, l, 1, 1, 2)
OS2Layout.addWidget(usWinAscentLabel, l, 3)
OS2Layout.addWidget(self.usWinAscentEdit, l, 4, 1, 2)
l += 1
OS2Layout.addWidget(sTypoDescenderLabel, l, 0)
OS2Layout.addWidget(self.sTypoDescenderEdit, l, 1, 1, 2)
OS2Layout.addWidget(usWinDescentLabel, l, 3)
OS2Layout.addWidget(self.usWinDescentEdit, l, 4, 1, 2)
l += 1
OS2Layout.addWidget(sTypoLineGapLabel, l, 0)
OS2Layout.addWidget(self.sTypoLineGapEdit, l, 1, 1, 2)
l += 1
OS2Layout.addWidget(ySubscriptXSizeLabel, l, 0)
OS2Layout.addWidget(self.ySubscriptXSizeEdit, l, 1, 1, 2)
OS2Layout.addWidget(ySubscriptXOffsetLabel, l, 3)
OS2Layout.addWidget(self.ySubscriptXOffsetEdit, l, 4, 1, 2)
l += 1
OS2Layout.addWidget(ySubscriptYSizeLabel, l, 0)
OS2Layout.addWidget(self.ySubscriptYSizeEdit, l, 1, 1, 2)
OS2Layout.addWidget(ySubscriptYOffsetLabel, l, 3)
OS2Layout.addWidget(self.ySubscriptYOffsetEdit, l, 4, 1, 2)
l += 1
OS2Layout.addWidget(ySuperscriptXSizeLabel, l, 0)
OS2Layout.addWidget(self.ySuperscriptXSizeEdit, l, 1, 1, 2)
OS2Layout.addWidget(ySuperscriptXOffsetLabel, l, 3)
OS2Layout.addWidget(self.ySuperscriptXOffsetEdit, l, 4, 1, 2)
l += 1
OS2Layout.addWidget(ySuperscriptYSizeLabel, l, 0)
OS2Layout.addWidget(self.ySuperscriptYSizeEdit, l, 1, 1, 2)
OS2Layout.addWidget(ySuperscriptYOffsetLabel, l, 3)
OS2Layout.addWidget(self.ySuperscriptYOffsetEdit, l, 4, 1, 2)
l += 1
OS2Layout.addWidget(yStrikeoutSizeLabel, l, 0)
OS2Layout.addWidget(self.yStrikeoutSizeEdit, l, 1, 1, 2)
OS2Layout.addWidget(yStrikeoutPositionLabel, l, 3)
OS2Layout.addWidget(self.yStrikeoutPositionEdit, l, 4, 1, 2)
# OS2Group.setLayout(OS2Layout)
self.setLayout(OS2Layout)
def _updateFsTypeVisibility(self, index):
if index == 0:
# TODO: maybe uncheck as well?
self.allowSubsettingBox.setEnabled(False)
self.allowBitmapEmbeddingBox.setEnabled(False)
else:
self.allowSubsettingBox.setEnabled(True)
self.allowBitmapEmbeddingBox.setEnabled(True)
def writeValues(self, font):
self.writePositiveInteger(font, "usWeightClass",
"openTypeOS2WeightClass")
self.writeInteger(font, "sTypoAscender", "openTypeOS2TypoAscender")
self.writeInteger(font, "sTypoDescender", "openTypeOS2TypoDescender")
self.writeInteger(font, "sTypoLineGap", "openTypeOS2TypoLineGap")
self.writePositiveInteger(font, "usWinAscent", "openTypeOS2WinAscent")
self.writePositiveInteger(font, "usWinDescent",
"openTypeOS2WinDescent")
self.writeInteger(font, "ySubscriptXSize", "openTypeOS2SubscriptXSize")
self.writeInteger(font, "ySubscriptYSize", "openTypeOS2SubscriptYSize")
self.writeInteger(font, "ySubscriptXOffset",
"openTypeOS2SubscriptXOffset")
self.writeInteger(font, "ySubscriptYOffset",
"openTypeOS2SubscriptYOffset")
self.writeInteger(font, "ySuperscriptXSize",
"openTypeOS2SuperscriptXSize")
self.writeInteger(font, "ySuperscriptYSize",
"openTypeOS2SuperscriptYSize")
self.writeInteger(font, "ySuperscriptXOffset",
"openTypeOS2SuperscriptXOffset")
self.writeInteger(font, "ySuperscriptYOffset",
"openTypeOS2SuperscriptYOffset")
self.writeInteger(font, "yStrikeoutSize", "openTypeOS2StrikeoutSize")
self.writeInteger(font, "yStrikeoutPosition",
"openTypeOS2StrikeoutPosition")
fsSelectionModel = self.fsSelectionList.model()
fsSelection = []
for i in range(7):
item = fsSelectionModel.item(i)
if item.checkState() == Qt.Checked:
fsSelection.append(i)
if len(fsSelection):
font.info.openTypeOS2Selection = fsSelection
else:
# XXX: None or empty array? should distinct those cases
font.info.openTypeOS2Selection = None
fsTypeIndex = self.fsTypeDrop.currentIndex()
fsType = []
if fsTypeIndex > 0:
fsType.append(fsTypeIndex)
if not self.allowSubsettingBox.isChecked():
fsType.append(8)
if self.allowBitmapEmbeddingBox.isChecked():
fsType.append(9)
# TODO: provide a way to represent None w this?
font.info.openTypeOS2Type = fsType
# TODO: see if data needs to be padded to 4 chars.
# I think that this is to be deferred to ufo2fdk(?)
font.info.openTypeOS2VendorID = self.achVendorIDEdit.text()
class FolderSwitch(QWidget):
def __init__(self, main_widget):
super(FolderSwitch, self).__init__(main_widget)
self.selected_folder = 0
self.main = main_widget
switchLayout = QVBoxLayout()
switchLayout.setContentsMargins(20, 20, 20, 20)
icon = QLabel()
icon.setFixedWidth(80)
myPixmap = QtGui.QPixmap(Directory().get_resource_dir() + 'icon.png')
myScaledPixmap = myPixmap.scaled(icon.size(),
QtCore.Qt.KeepAspectRatio)
icon.setPixmap(myScaledPixmap)
header = QLabel()
header.setText("Select notebook:")
self.folders = QListView()
self.folders.setModel(Database().get_folder_model())
self.folders.clicked[QModelIndex].connect(self.select_folder)
buttons = QWidget()
buttons_layout = QHBoxLayout()
self.button_ok = QPushButton("OK")
self.button_add = QPushButton("Add")
self.button_cancel = QPushButton("Cancel")
self.button_edit = QPushButton("Change name")
buttons_layout.addWidget(self.button_add)
buttons_layout.addWidget(self.button_edit)
buttons_layout.addStretch()
buttons_layout.addWidget(self.button_ok)
buttons_layout.addWidget(self.button_cancel)
buttons.setLayout(buttons_layout)
self.button_cancel.clicked.connect(self.cancel)
self.button_ok.clicked.connect(self.ok)
self.button_add.clicked.connect(self.add)
self.button_edit.clicked.connect(self.edit)
# stack
switchLayout.addWidget(icon)
switchLayout.addWidget(header)
switchLayout.addWidget(self.folders)
switchLayout.addStretch()
switchLayout.addWidget(buttons)
main_widget.setLayout(switchLayout)
main_widget.hide()
def select_folder(self, index):
item = self.folders.model().itemFromIndex(index)
self.selected_folder = item.folder_id
def cancel(self):
self.main.hide()
def ok(self):
self.main.parent().load_folder(self.selected_folder)
self.main.hide()
def add(self):
new_folder, ok = QInputDialog.getText(self, 'Hummingbird',
'New notebook name:')
if ok:
db = Database()
db.insert_folder(str(new_folder))
self.folders.setModel(db.get_folder_model())
def edit(self):
new_name, ok = QInputDialog.getText(self, 'Hummingbird',
'New notebook name:')
if ok:
db = Database()
db.update_folder(self.selected_folder, str(new_name))
self.folders.setModel(db.get_folder_model())
class ToDoList(QWidget):
def __init__(self, parent, component_def):
super(ToDoList, self).__init__(parent)
self.component = component_def
self.layout = QVBoxLayout()
self.list = QListView()
self.list.setWordWrap(True)
self.list.setVerticalScrollMode(QAbstractItemView.ScrollPerPixel)
self.list.verticalScrollBar().setSingleStep(5)
self.form = QVBoxLayout()
self.buttons = QHBoxLayout()
self.add = QPushButton("Add")
self.add.clicked.connect(self.action_add)
self.label = QLineEdit()
self.label.setPlaceholderText("new task name")
self.label.returnPressed.connect(self.add.click)
self.priority = QComboBox()
self.priority.insertItem(0, "Low")
self.priority.insertItem(1, "Medium")
self.priority.insertItem(2, "High")
self.priority.insertItem(3, "Critical")
self.priority.setCurrentIndex(1)
self.stack()
def stack(self):
self.layout.addWidget(self.list)
self.form.addWidget(self.label)
self.buttons.addWidget(self.priority)
self.buttons.addWidget(self.add)
self.form.addLayout(self.buttons)
self.layout.addLayout(self.form)
self.setLayout(self.layout)
def load(self, folder):
model = Database().get_task_model(folder)
self.list.setModel(model)
#self.list.clicked[QModelIndex].connect(self.item_check)
#def item_check(self, index):
# item = self.list.model().itemFromIndex(index)
# if item.checkState() == QtCore.Qt.Checked:
def action_add(self):
if self.label.text() != "":
item = ToDoItem()
item.label = self.label.text()
item.date = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
item.priority = Priority(self.priority.currentIndex())
item.setSelectable(True)
item.setEditable(False)
item.setCheckable(True)
idx = self.get_index_of_priority_to_insert(item.priority)
self.list.model().insertRow(idx, item)
self.label.setText("")
def get_index_of_priority_to_insert(self, priority):
p = int(priority)
c = self.list.model().rowCount()
# print("inserted priority = %d" % p)
for idx in range(0, c):
item = self.list.model().item(idx)
if int(item.priority) <= p:
return idx
return c
def save(self, folder):
model = self.list.model()
result = False
for index in range(model.rowCount()):
item = model.item(index)
if item.id == 0:
item.id = Database().insert_task(folder, item)
result = True
else:
if item.checkState() == QtCore.Qt.Checked:
Database().check_task(item.id)
result = True
self.tidy_up()
return result
def tidy_up(self):
go_on = self.list.model().rowCount() > 0
i = 0
while go_on:
if self.list.model().item(i).checkState() == QtCore.Qt.Checked:
self.list.model().removeRow(i)
else:
i += 1
go_on = i < self.list.model().rowCount()
def focus(self):
self.list.setFocus()
class LocationCompleterView(QWidget):
def __init__(self):
super().__init__(None)
self._view = None # QListView
self._delegate = None # LocationCompleterDelegate
self._searchEnginesLayout = None # QHBoxLayout
self._resizeHeight = -1
self._resizeTimer = None # QTimer
self._forceResize = True
self.setAttribute(Qt.WA_ShowWithoutActivating)
self.setAttribute(Qt.WA_X11NetWmWindowTypeCombo)
if gVar.app.platformName() == 'xcb':
self.setWindowFlags(Qt.Window | Qt.FramelessWindowHint
| Qt.BypassWindowManagerHint)
else:
self.setWindowFlags(Qt.Popup)
layout = QVBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
self._view = QListView(self)
layout.addWidget(self._view)
self._view.setUniformItemSizes(True)
self._view.setEditTriggers(QAbstractItemView.NoEditTriggers)
self._view.setVerticalScrollMode(QAbstractItemView.ScrollPerPixel)
self._view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self._view.setSelectionBehavior(QAbstractItemView.SelectRows)
self._view.setSelectionMode(QAbstractItemView.SingleSelection)
self._view.setMouseTracking(True)
gVar.app.installEventFilter(self)
self._delegate = LocationCompleterDelegate(self)
self._view.setItemDelegate(self._delegate)
searchFrame = QFrame(self)
searchFrame.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
searchLayout = QHBoxLayout(searchFrame)
searchLayout.setContentsMargins(10, 4, 4, 4)
searchSettingsButton = ToolButton(self)
searchSettingsButton.setIcon(IconProvider.settingsIcon())
searchSettingsButton.setToolTip(_('Manage Search Engines'))
searchSettingsButton.setAutoRaise(True)
searchSettingsButton.setIconSize(QSize(16, 16))
searchSettingsButton.clicked.connect(self.searchEnginesDialogRequested)
searchLabel = QLabel(_('Search with:'))
self._searchEnginesLayout = QHBoxLayout()
self._setupSearchEngines()
gVar.app.searchEnginesManager().enginesChanged.connect(
self._setupSearchEngines)
searchLayout.addWidget(searchLabel)
searchLayout.addLayout(self._searchEnginesLayout)
searchLayout.addStretch()
searchLayout.addWidget(searchSettingsButton)
layout.addWidget(searchFrame)
def model(self):
'''
@return: QAbstractItemModel
'''
return self._view.model()
def setModel(self, model):
'''
@param model QAbstractItemModel
'''
self._view.setModel(model)
def selectionModel(self):
'''
@return: QItemSelectionModel
'''
return self._view.selectionModel()
def currentIndex(self):
'''
@return: QModelIndex
'''
return self._view.currentIndex()
def setCurrentIndex(self, index):
'''
@param index QModelIndex
'''
self._view.setCurrentIndex(index)
def adjustSize(self):
maxItemsCount = 12
newHeight = self._view.sizeHintForRow(0) * min(maxItemsCount,
self.model().rowCount())
if not self._resizeTimer:
self._resizeTimer = QTimer(self)
self._resizeTimer.setInterval(200)
def func():
if self._resizeHeight > 0:
self._view.setFixedHeight(self._resizeHeight)
self.setFixedHeight(self.sizeHint().height())
self._resizeHeight = -1
self._resizeTimer.timeout.connect(func)
if not self._forceResize:
if newHeight == self._resizeHeight:
return
elif newHeight == self._view.height():
self._resizeHeight = -1
return
elif newHeight < self._view.height():
self._resizeHeight = newHeight
self._resizeTimer.start()
return
self._resizeHeight = -1
self._forceResize = False
self._view.setFixedHeight(newHeight)
self.setFixedHeight(self.sizeHint().height())
# override
def eventFilter(self, obj, event): # noqa C901
'''
@param obj QObject
@param event QEvent
@return: bool
'''
# Event filter based on QCompleter::eventFilter from qcompleter.cpp
if obj == self or obj == self._view or not self.isVisible():
return False
evtType = event.type()
if obj == self._view.viewport():
if evtType == QEvent.MouseButtonRelease:
# QMouseEvent
e = event
index = self._view.indexAt(e.pos())
if not index.isValid():
return False
# Qt::MouseButton
button = e.button()
# Qt::KeyboardModifiers
modifiers = e.modifiers()
if button == Qt.LeftButton and modifiers == Qt.NoModifier:
self.indexActivated.emit(index)
return True
if button == Qt.MiddleButton or (button == Qt.LeftButton
and modifiers
== Qt.ControlModifier):
self.indexCtrlActivated.emit(index)
return True
if button == Qt.LeftButton and modifiers == Qt.ShiftModifier:
self.indexShiftActivated.emit(index)
return True
return False
if evtType == QEvent.KeyPress:
# QKeyEvent
keyEvent = event
evtKey = keyEvent.key()
modifiers = keyEvent.modifiers()
index = self._view.currentIndex()
item = self.model().index(0, 0)
if item.data(LocationCompleterModel.VisitSearchItemRole):
visitSearchIndex = item
else:
visitSearchIndex = QModelIndex()
if (evtKey == Qt.Key_Up or evtKey == Qt.Key_Down) and \
self._view.currentIndex() != index:
self._view.setCurrentIndex(index) # TODO: ?
if evtKey in (Qt.Key_Return, Qt.Key_Enter):
if index.isValid():
if modifiers == Qt.NoModifier or modifiers == Qt.KeypadModifier:
self.indexActivated.emit(index)
return True
if modifiers == Qt.ControlModifier:
self.indexCtrlActivated.emit(index)
return True
if modifiers == Qt.ShiftModifier:
self.indexShiftActivated.emit(index)
return True
elif evtKey == Qt.Key_End:
if modifiers & Qt.ControlModifier:
self._view.setCurrentIndex(self.model().index(
self.model().rowCount() - 1, 0))
return True
else:
self.close()
elif evtKey == Qt.Key_Home:
if modifiers & Qt.ControlModifier:
self._view.setCurrentIndex(self.model().index(0, 0))
self._view.scrollToTop()
return True
else:
self.close()
elif evtKey == Qt.Key_Escape:
self.close()
return True
elif evtKey == Qt.Key_F4:
if modifiers == Qt.AltModifier:
self.close()
return False
elif evtKey in (Qt.Key_Tab, Qt.Key_Backtab):
if modifiers != Qt.NoModifier and modifiers != Qt.ShiftModifier:
return False
isBack = evtKey == Qt.Key_Backtab
if evtKey == Qt.Key_Tab and modifiers == Qt.ShiftModifier:
isBack = True
ev = QKeyEvent(QKeyEvent.KeyPress, isBack and Qt.Key_Up
or Qt.Key_Down, Qt.NoModifier)
QApplication.sendEvent(self.focusProxy(), ev)
return True
elif evtKey in (Qt.Key_Up, Qt.Key_PageUp):
if modifiers != Qt.NoModifier:
return False
step = evtKey == Qt.Key_PageUp and 5 or 1
if not index.isValid() or index == visitSearchIndex:
rowCount = self.model().rowCount()
lastIndex = self.model().index(rowCount - 1, 0)
self._view.setCurrentIndex(lastIndex)
elif index.row() == 0:
self._view.setCurrentIndex(QModelIndex())
else:
row = max(0, index.row() - step)
self._view.setCurrentIndex(self.model().index(row, 0))
return True
elif evtKey in (Qt.Key_Down, Qt.Key_PageDown):
if modifiers != Qt.NoModifier:
return False
step = evtKey == Qt.Key_PageDown and 5 or 1
if not index.isValid():
firstIndex = self.model().index(0, 0)
self._view.setCurrentIndex(firstIndex)
elif index != visitSearchIndex and index.row(
) == self.model().rowCount() - 1:
self._view.setCurrentIndex(visitSearchIndex)
self._view.scrollToTop()
else:
row = min(self.model().rowCount() - 1, index.row() + step)
self._view.setCurrentIndex(self.model().index(row, 0))
return True
elif evtKey == Qt.Key_Delete:
if index != visitSearchIndex and self._view.viewport().rect(
).contains(self._view.visualRect(index)):
self.indexDeleteRequested.emit(index)
return True
elif evtKey == Qt.Key_Shift:
self._delegate.setForceVisitItem(True)
self._view.viewport().update()
# end of switch evtKey
if self.focusProxy():
self.focusProxy().event(keyEvent)
return True
elif evtType == QEvent.KeyRelease:
if event.key() == Qt.Key_Shift:
self._delegate.setForceVisitItem(False)
self._view.viewport().update()
return True
elif evtType in (QEvent.Wheel, QEvent.MouseButtonPress):
if not self.underMouse():
self.close()
return False
elif evtType == QEvent.FocusOut:
# QFocusEvent
focusEvent = event
reason = focusEvent.reason()
if reason != Qt.PopupFocusReason and reason != Qt.MouseFocusReason:
self.close()
elif evtType in (QEvent.Move, QEvent.Resize):
w = obj
if isinstance(w, QWidget) and w.isWindow() and self.focusProxy(
) and w == self.focusProxy().window():
self.close()
# end of switch evtType
return False
# Q_SIGNALS
closed = pyqtSignal()
searchEnginesDialogRequested = pyqtSignal()
loadRequested = pyqtSignal(LoadRequest)
indexActivated = pyqtSignal(QModelIndex)
indexCtrlActivated = pyqtSignal(QModelIndex)
indexShiftActivated = pyqtSignal(QModelIndex)
indexDeleteRequested = pyqtSignal(QModelIndex)
# public Q_SLOTS:
def close(self):
self.hide()
self._view.verticalScrollBar().setValue(0)
self._delegate.setForceVisitItem(False)
self._forceResize = True
self.closed.emit()
# private:
def _setupSearchEngines(self):
for idx in (range(self._searchEnginesLayout.count())):
item = self._searchEnginesLayout.takeAt(0)
item.deleteLater()
engines = gVar.app.searchEnginesManager().allEngines()
for engine in engines:
button = ToolButton(self)
button.setIcon(engine.icon)
button.setToolTip(engine.name)
button.setAutoRaise(True)
button.setIconSize(QSize(16, 16))
def func():
text = self.model().index(0, 0).data(
LocationCompleterModel.SearchStringRole)
self.loadRequested.emit(
gVar.app.searchEngineManager().searchResult(engine, text))
button.clicked.connect(func)
self._searchEnginesLayout.addWidget(button)
class SelectPluginWindow(QDialog):
def __init__(self, app, parent=None):
try:
super(SelectPluginWindow, self).__init__(parent=parent)
self.app = app
self.setWindowTitle("Select Plugins")
form = QFormLayout(self)
form.addRow(QLabel("Plugin site:"))
self.textbox = QLineEdit(self)
self.textbox.setText(
"https://tissuumaps.github.io/TissUUmaps/plugins/")
form.addRow(self.textbox)
# Create a button in the window
self.button = QPushButton('Get plugins from site', self)
self.button.move(20, 80)
form.addRow(self.button)
# connect button to function on_click
self.button.clicked.connect(self.getPlugins)
form.addRow(QLabel("Available plugins:"))
self.listView = QListView(self)
form.addRow(self.listView)
buttonBox = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal,
self)
form.addRow(buttonBox)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.reject)
self.getPlugins()
except:
import traceback
print(traceback.format_exc())
def getPlugins(self):
self.url = self.textbox.text()
try:
response = urllib.request.urlopen(self.url + "pluginList.json")
self.items = json.loads(response.read())
for plugin in self.items:
if plugin["py"].replace(".py",
"") in self.app.config["PLUGINS"]:
plugin["installed"] = True
else:
plugin["installed"] = False
model = QStandardItemModel(self.listView)
for item in self.items:
# create an item with a caption
standardItem = QStandardItem(item["name"])
standardItem.setCheckState(
Qt.Checked if item["installed"] else Qt.Unchecked)
if not item["installed"]:
standardItem.setCheckable(True)
standardItem.setEditable(False)
model.appendRow(standardItem)
self.listView.setModel(model)
except:
import traceback
try:
QMessageBox.warning(self, "Error", traceback.format_exc())
except:
print(traceback.format_exc())
def itemsSelected(self):
selected = []
model = self.listView.model()
i = 0
while model.item(i):
if model.item(i).checkState():
selected.append(self.items[i])
i += 1
return selected
class AbstractSubItemListView(QFrame):
"""
THIS IS AN ABSTRACT CLASS, DO NOT INSTANTIATE
"""
def __init__(self, parent: QObject, image_cache: ImageCache):
super().__init__(parent)
self._image_cache = image_cache
self._model = AbstractItemListModel(self, image_cache, True)
self._item_delegate = ItemDelegate(self)
self._list_view = QListView(self)
self._list_view.setItemDelegate(self._item_delegate)
self._list_view.setContextMenuPolicy(Qt.CustomContextMenu)
self._layout_manager = QVBoxLayout(self)
self._layout_ui()
# Connect signals to slots
self._list_view.customContextMenuRequested.connect(self._show_context_menu)
def _layout_ui(self):
self._list_view.setSpacing(22)
self._layout_manager.addWidget(self._list_view)
def model(self) -> AbstractItemListModel:
return self._model
def _add_item_to_playlist(self, index: QModelIndex):
"""
Given an index in the list, allows the user to add the selected item to a playlist of their choice
"""
selected_item = self._list_view.model().at(index.row())
add_dialog = AddToPlaylistDialog(self, selected_item)
if add_dialog.exec() == QDialog.Accepted:
# Insertion playlist has been accepted
selected_playlist_id: int = add_dialog.get_selection()
if type(selected_item) is Episode:
add_episode_to_playlist(cursor, connection, selected_item.media_id, selected_item.episode_number,
selected_item.name, selected_playlist_id)
elif type(selected_item) is Song:
add_song_to_playlist(cursor, connection, selected_item.media_id, selected_item.name,
selected_playlist_id)
elif type(selected_item) is ComedySpecial:
add_comedy_special_to_playlist(cursor, connection, selected_item.media_id, selected_playlist_id)
else:
print("Attempting to add unexpected type to playlist")
exit(1)
@QtCore.pyqtSlot(QPoint)
def _show_context_menu(self, pos: QPoint):
"""
Displays a context menu of user choices on a right-click
:param pos: Location where user clicked on the screen
"""
index = self._list_view.indexAt(pos)
if index.row() != -1: # Must be a valid index
global_pos = self._list_view.mapToGlobal(pos)
context_menu = QMenu(self)
# User should have the ability to add to playlist
add_action = QAction("Add to playlist")
add_action.triggered.connect(lambda: self._add_item_to_playlist(index))
context_menu.addAction(add_action)
context_menu.exec(global_pos)
del context_menu
class DictView(QWidget):
BTN_ADDWORD_TEXT = 'Add'
BTN_RMWORD_TEXT = 'Remove'
def __init__(self, parent: QObject = None, model: WordListModel = None, **kwargs):
super().__init__(parent, **kwargs)
self.lhb_control = QHBoxLayout()
self.layout = QVBoxLayout()
self.b_addword = QPushButton(self.BTN_ADDWORD_TEXT)
self.b_rmword = QPushButton(self.BTN_RMWORD_TEXT)
self.cmb_wordclass = QComboBox()
for wc in WordClass:
self.cmb_wordclass.addItem(wc.name)
self.hsplitter = QSplitter(Qt.Horizontal)
self.wordlistview = QListView()
self.wordeditview = WordEditView()
self.wordlsmdl = model
self.wordlistview.activated.connect(self.wordeditview.handle_wordlistitem_activated)
self.hsplitter.addWidget(self.wordlistview)
self.hsplitter.addWidget(self.wordeditview)
self.hsplitter.setSizes([PyDictAppView.DESKTOP_DEFAULT_WIDTH * 0.4, PyDictAppView.DESKTOP_DEFAULT_WIDTH * 0.6])
self.lhb_control.addWidget(self.cmb_wordclass)
self.lhb_control.addWidget(self.b_addword)
self.lhb_control.addWidget(self.b_rmword)
self.lhb_control.addStretch()
self.layout.addLayout(self.lhb_control)
self.layout.addWidget(self.hsplitter)
self.setLayout(self.layout)
self.b_addword.clicked.connect(self.handle_b_addword_clicked)
self.b_rmword.clicked.connect(self.handle_b_rmword_clicked)
@property
def wordlsmdl(self) -> WordListModel:
return self.wordlistview.model()
@wordlsmdl.setter
def wordlsmdl(self, value: WordListModel) -> None:
assert (value is None) or isinstance(value, WordListModel), 'The wordlsmdl property of {} class shall have {} type.'\
.format(self.__class__.__name__, WordListModel.__name__)
self.wordlistview.setModel(value)
self.wordeditview.wordlsmdl = value
def handle_b_addword_clicked(self) -> None:
wc = self.parse_wordclass()
word_dialog = WordDialog(wc, self.wordlsmdl, self)
word_dialog.show()
word_dialog.exec()
def handle_b_rmword_clicked(self) -> None:
self.wordeditview.activate_wordview(None)
sel_indexes = self.wordlistview.selectionModel().selectedIndexes()
if sel_indexes is not None:
for index in sel_indexes:
guid = self.wordlsmdl.get_guid(index)
event_wordremreq = EventWordRemoveRequest(guid)
event_wordremreq.fire()
def parse_wordclass(self) -> WordClass:
wordclass_text = self.cmb_wordclass.currentText()
if WordClass.__members__.get(wordclass_text) is None:
return WordClass.NOUN
else:
return WordClass[wordclass_text]
class ObjectFileView(QDialog):
def __init__(self, name):
super().__init__()
self.setWindowTitle(name)
with open(
os.path.join(get_jak_path(), "decompiler_out",
"{}_asm.json".format(name))) as f:
self.asm_data = json.loads(f.read())
main_layout = QVBoxLayout()
monospaced_font = get_monospaced_font()
self.header_label = QLabel()
main_layout.addWidget(self.header_label)
function_splitter = QSplitter()
function_splitter.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding))
self.function_list = QTreeView()
self.function_list_model = QStandardItemModel()
self.functions_by_name = dict()
root = self.function_list_model.invisibleRootItem()
seg_roots = []
for i in range(3):
seg_entry = QStandardItem(segment_id_to_name(i))
seg_entry.setFont(monospaced_font)
seg_entry.setEditable(False)
root.appendRow(seg_entry)
seg_roots.append(seg_entry)
for f in self.asm_data["functions"]:
function_entry = QStandardItem(f["name"])
function_entry.setFont(monospaced_font)
function_entry.setEditable(False)
seg_roots[f["segment"]].appendRow(function_entry)
self.functions_by_name[f["name"]] = f
self.header_label.setText(
"Object File {} Functions ({} total):".format(
name, len(self.asm_data["functions"])))
self.function_list.setModel(self.function_list_model)
self.function_list.clicked.connect(self.display_function)
function_splitter.addWidget(self.function_list)
layout = QVBoxLayout()
self.function_header_label = QLabel("No function selected")
self.function_header_label.setFont(monospaced_font)
self.header_label.setSizePolicy(
QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum))
layout.addWidget(self.function_header_label)
self.op_asm_split_view = QSplitter()
self.op_asm_split_view.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding))
self.basic_op_pane = QListView()
self.basic_op_pane.clicked.connect(self.basic_op_clicked)
#layout.addWidget(self.basic_op_pane)
self.op_asm_split_view.addWidget(self.basic_op_pane)
self.asm_pane = QListView()
self.op_asm_split_view.addWidget(self.asm_pane)
layout.addWidget(self.op_asm_split_view)
self.asm_display = QPlainTextEdit()
self.asm_display.setMaximumHeight(80)
layout.addWidget(self.asm_display)
self.warnings_label = QLabel()
layout.addWidget(self.warnings_label)
widget = QWidget()
widget.setLayout(layout)
function_splitter.addWidget(widget)
main_layout.addWidget(function_splitter)
# add it to the window!
self.setLayout(main_layout)
def display_function(self, item):
name = item.data()
monospaced_font = get_monospaced_font()
func = self.functions_by_name[name]
basic_op_model = QStandardItemModel()
basic_op_root = basic_op_model.invisibleRootItem()
asm_model = QStandardItemModel()
asm_root = asm_model.invisibleRootItem()
self.basic_id_to_asm = []
self.current_function = name
op_idx = 0
basic_idx = 0
for op in func["asm"]:
if "label" in op:
asm_item = QStandardItem(op["label"] + "\n " + op["asm_op"])
else:
asm_item = QStandardItem(" " + op["asm_op"])
asm_item.setFont(monospaced_font)
asm_item.setEditable(False)
asm_root.appendRow(asm_item)
if "basic_op" in op:
if "label" in op:
basic_item = QStandardItem(op["label"] + "\n " +
op["basic_op"])
else:
basic_item = QStandardItem(" " + op["basic_op"])
basic_item.setFont(monospaced_font)
basic_item.setEditable(False)
basic_op_root.appendRow(basic_item)
self.basic_id_to_asm.append(op_idx)
basic_idx = basic_idx + 1
op_idx = op_idx + 1
self.basic_id_to_asm.append(op_idx)
self.basic_op_pane.setModel(basic_op_model)
self.asm_pane.setModel(asm_model)
self.warnings_label.setText(func["warnings"])
self.asm_display.setPlainText("")
self.function_header_label.setText(
"{}, type: {}\nfunc: {} obj: {}".format(name, func["type"],
func["name"],
func["parent_object"]))
def basic_op_clicked(self, item):
text = ""
added_reg = 0
asm_idx = self.basic_id_to_asm[item.row()]
asm_op = self.functions_by_name[self.current_function]["asm"][asm_idx]
if "type_map" in asm_op:
for reg, type_name in asm_op["type_map"].items():
text += "{}: {} ".format(reg, type_name)
added_reg += 1
if added_reg >= 4:
text += "\n"
added_reg = 0
text += "\n"
for i in range(asm_idx, self.basic_id_to_asm[item.row() + 1]):
text += self.functions_by_name[
self.current_function]["asm"][i]["asm_op"] + "\n"
op = self.functions_by_name[self.current_function]["asm"][asm_idx]
if "referenced_string" in op:
text += op["referenced_string"]
self.asm_display.setPlainText(text)
self.asm_display.setFont(get_monospaced_font())
self.asm_pane.setCurrentIndex(self.asm_pane.model().index(asm_idx, 0))
class PlaylistView(QFrame):
"""
Horizontal Scroll Area containing playlists that can be selected
"""
# Signals
should_display_playlist = pyqtSignal(
int) # Display playlist given playlist_id
def __init__(self, parent: QObject, image_cache: ImageCache):
super().__init__(parent)
self.__item_delegate = PlaylistDelegate(self)
self.__model = PlaylistModel(self, image_cache)
self.__horizontal_list = QListView(self)
self.__horizontal_list.setModel(self.__model)
self.__horizontal_list.setItemDelegate(self.__item_delegate)
self.__horizontal_list.verticalScrollBar().setEnabled(False)
self.__horizontal_list.setContextMenuPolicy(Qt.CustomContextMenu)
self.__layout_manager = QVBoxLayout(self)
self.__layout_ui()
# Connect signals to slots
self.__horizontal_list.doubleClicked.connect(
self.__playlist_double_clicked)
self.__horizontal_list.customContextMenuRequested.connect(
self.__show_context_menu)
def __layout_ui(self):
# Set up horizontal list
self.__horizontal_list.setFlow(QListView.LeftToRight)
self.__horizontal_list.setMinimumHeight(235)
self.__horizontal_list.setSpacing(20)
self.__layout_manager.addWidget(self.__horizontal_list)
def model(self) -> PlaylistModel:
return self.__model
@QtCore.pyqtSlot(QModelIndex)
def __playlist_double_clicked(self, index: QModelIndex):
"""
Slot that connects to the doubleClicked signal
Should either display contents of the playlist or allow for playlist creation (index dependent)
:index: Index that was clicked
"""
should_create_playlist = (index.row() != self.__model.rowCount() - 1)
if should_create_playlist:
# Didn't click last index (create playlist), should display contents
self.should_display_playlist.emit(
self.__model.at(index.row()).playlist_id)
else:
self.__model.create_new_playlist()
@QtCore.pyqtSlot(QModelIndex)
def __handle_playlist_rename(self, index: QModelIndex):
"""
Allows the user to rename the playlist at index
"""
playlist = self.__model.at(index.row())
rename_dialog = RenamePlaylistDialog(self, playlist)
if rename_dialog.exec() == QDialog.Accepted:
# Rename successfully requested
new_playlist_name = rename_dialog.get_new_name()
rename_playlist(cursor, connection, playlist.playlist_id,
new_playlist_name)
self.relayout()
@QtCore.pyqtSlot(QPoint)
def __show_context_menu(self, pos: QPoint):
"""
Displays a context menu of user choices on a right-click
:param pos: Location where user clicked on the screen
"""
index = self.__horizontal_list.indexAt(pos)
if index.row() != -1 and index.row() != self.__model.rowCount(
) - 1: # Must be a valid index and not create
global_pos = self.__horizontal_list.mapToGlobal(pos)
context_menu = QMenu(self)
show_action = QAction("Show Playlist")
show_action.triggered.connect(
lambda: self.__playlist_double_clicked(index))
rename_action = QAction("Rename Playlist")
rename_action.triggered.connect(
lambda: self.__handle_playlist_rename(index))
del_action = QAction("Delete Playlist")
del_action.triggered.connect(
lambda: self.__horizontal_list.model().delete_playlist(index))
context_menu.addAction(show_action)
context_menu.addSeparator()
context_menu.addAction(rename_action)
context_menu.addAction(del_action)
context_menu.exec(global_pos)
del context_menu
def relayout(self):
"""
Refreshes the UI to reflect the state of the DB
"""
playlists = get_all_user_playlists(cursor)
self.__model.update_playlist(playlists)
class Drop(QWidget):
add_path_signal = pyqtSignal(str)
add_drag_n_drop_path_signal = pyqtSignal(str)
remove_path_signal = pyqtSignal(str)
export_all_signal = pyqtSignal(tuple)
def __init__(self, parent=None):
super().__init__(parent)
# Window creation
bg = self.palette()
bg.setColor(QPalette.Window, Qt.white)
self.setPalette(bg)
self.setFixedSize(340, 450)
self.setWindowTitle("HPLC a Excel")
self.setAcceptDrops(True)
# Button creation
self.btn_load_files = QPushButton("Cargar archivos", self)
self.btn_export = QPushButton("Exportar todos a Excel", self)
self.btn_remove_checked = QPushButton("Descartar seleccionados", self)
self.btn_config = QPushButton("", self)
self.btn_config.setIcon(QIcon("ui/gear.png"))
self.btn_config.setMaximumWidth(30)
self.btn_config.setToolTip("Configuración (Ctrl + K)")
self.btn_config.setShortcut(Qt.CTRL + Qt.Key_K)
# Label creation
self.copyright = QLabel("DIQB UC - Víctor Tirreau - 2018", self)
self.copyright.setStyleSheet("color: #444444;")
self.copyright.setAlignment(Qt.AlignCenter)
# Button connection
self.btn_load_files.clicked.connect(self.get_files)
self.btn_remove_checked.clicked.connect(self.remove_checked)
self.btn_export.clicked.connect(self.open_export_dialog)
self.btn_config.clicked.connect(self.open_config_dialog)
# Signal connection
self.back = backend.PDFToExcel(self)
self.add_path_signal.connect(self.back.add_paths)
self.remove_path_signal.connect(self.back.remove_paths)
self.add_drag_n_drop_path_signal.connect(
self.back.add_paths_drag_n_drop)
self.export_all_signal.connect(self.back.export_pdf_to_excel)
# List
self.list = QListView(self)
self.model = QStandardItemModel(self.list)
self.list.setModel(self.model)
# Layout
top_h_box = QHBoxLayout()
top_h_box.addWidget(self.btn_load_files)
top_h_box.addWidget(self.btn_config)
lower_h_box = QHBoxLayout()
lower_h_box.addWidget(self.btn_remove_checked)
lower_h_box.addStretch(10)
lower_h_box.addWidget(self.btn_export)
v_box = QVBoxLayout()
v_box.addLayout(top_h_box)
v_box.addWidget(self.list)
v_box.addLayout(lower_h_box)
v_box.addWidget(self.copyright)
h_box = QHBoxLayout()
h_box.addLayout(v_box)
self.setLayout(h_box)
# Config
self.include_od = False
def dragEnterEvent(self, event):
if event.mimeData().hasText():
event.acceptProposedAction()
else:
event.ignore()
dragMoveEvent = dragEnterEvent
def dropEvent(self, event):
files = event.mimeData().text()
self.add_drag_n_drop_path_signal.emit(files)
def get_files(self):
files, _ = QFileDialog.getOpenFileNames(
self,
"Elegir uno o más archivos PDF",
"",
"Archivos PDF (*.pdf)")
if files:
for file in files:
self.add_path_signal.emit(file)
def remove_checked(self):
model = self.list.model()
to_be_removed = [model.item(i) for i in range(model.rowCount()) if
model.item(i).checkState() == Qt.Checked]
for path in to_be_removed:
self.remove_path_signal.emit(path.file_name)
def add_path_to_list(self, path_str):
model = self.list.model()
item = CustomStandardItem(path_str)
item.setCheckable(True)
item.setToolTip("Aún no procesado")
item.setEditable(False)
model.appendRow(item)
def drop_path_from_list(self, path_str):
model = self.list.model()
pos = 0
while pos < model.rowCount():
item = model.item(pos)
if item.file_name == path_str:
model.removeRow(pos)
break
pos += 1
def open_export_dialog(self):
path = QFileDialog.getExistingDirectory(self,
"Elegir carpeta para guardar "
"Excel's")
self.export_all_signal.emit((path,self.include_od))
def open_config_dialog(self):
dialog = QDialog(None, Qt.WindowCloseButtonHint)
dialog.setWindowTitle("Configuración")
dialog.setModal(True)
check = QCheckBox("Agregar columnas de rendimiento (OD y mg/g)", dialog)
check.setChecked(self.include_od)
v_box = QVBoxLayout()
v_box.addWidget(check)
cancel = QPushButton("Cancelar", dialog)
cancel.setShortcut(QKeySequence(Qt.Key_Escape))
accept = QPushButton("Aceptar", dialog)
accept.setShortcut(QKeySequence(Qt.Key_Enter))
accept.setFocusPolicy(Qt.TabFocus)
accept.setDefault(True)
h_box = QHBoxLayout()
h_box.addWidget(cancel)
h_box.addWidget(accept)
v_box.addStretch(1)
v_box.addLayout(h_box)
dialog.setFixedSize(300, 100)
dialog.setLayout(v_box)
cancel.clicked.connect(dialog.reject)
accept.clicked.connect(dialog.accept)
dialog.accepted.connect(lambda: apply_changes(check.checkState()))
def apply_changes(state):
self.include_od = state
dialog.exec_()
@pyqtSlot(tuple)
def change_color_finished(self, args):
file_name, res = args
model = self.list.model()
pos = 0
while pos < model.rowCount():
item = model.item(pos)
if item.file_name == file_name:
if res == 0:
item.setBackground(QColor("#bfb"))
item.setToolTip(f"Procesado correcto - {file_name}")
text = item.file_name
text = text[:34] + "..." if len(text) > 37 else text
text = "OK " + text.ljust(38)
item.setText(text)
else:
item.setBackground(QColor(250, 150, 150))
if res == 1:
item.setToolTip(
f"ERROR: El archivo {file_name} no tiene "
f"estándares")
text = item.file_name
text = text[:17] + "..." if len(text) > 21 else text
text += " no tiene estándares"
item.setText(text)
if res == 2:
item.setToolTip(
f"ERROR: El archivo {file_name} está abierto por"
f" otro programa")
text = item.file_name
text = text[:17] + "..." if len(text) > 21 else text
text += " está en uso por otro programa"
item.setText(text)
if res == 3:
item.setToolTip(
f"ERROR: El archivo {file_name} dio un error "
f"desconocido")
text = item.file_name
text = text[:17] + "..." if len(text) > 21 else text
text += " error desconocido"
item.setText(text)
break
pos += 1
@pyqtSlot(tuple)
def progress_started(self, args):
file_name, progress = args
model = self.list.model()
pos = 0
while pos < model.rowCount():
item = model.item(pos)
if item.file_name == file_name:
item.set_progress(progress)
item.setToolTip(f"Procesando {file_name}")
text = item.file_name
text = text[:25] + "..." if len(text) > 28 else text
text += " procesando"
item.setText(text)
break
pos += 1
def closeEvent(self, event):
QThreadPool.globalInstance().waitForDone()
print("Bye")
event.accept()
class LocationView(QWidget):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# TODO load this from the data layer
self.name = "Your Home" # the name of the shown location
self.ppl = []
self.push_alt_views = []
self.push_actions = []
self.push_ctl = []
nrof_actions = 3
nrof_controls = 2
# create widgets
self.site_view = QScalingNoticeBoard(parent=self)
self.person_interact = PersonInteraction(self)
self.people_list = QListView(self)
self.calendar_notes_lbl = QLabel(self)
self.person_site_lbl = QLabel(self)
# create layout
grid = QGridLayout(self)
grid.setRowStretch(0, 2)
grid.setColumnStretch(0, 1)
grid.setColumnStretch(1, 7)
grid.setColumnStretch(2, 2)
grid.addWidget(self.site_view, 0, 0, 1, 2)
grid.addWidget(self.people_list, 0, 2, 1, 1)
hbox2 = QHBoxLayout()
for _ in range(nrof_actions):
pushbtn = QPushButton(self)
hbox2.addWidget(pushbtn)
self.push_actions.append(pushbtn)
grid.addLayout(hbox2, 1, 0, 1, 1)
grid.addWidget(self.calendar_notes_lbl, 1, 1, 1, 1)
hbox3 = QHBoxLayout()
hbox3.addWidget(self.person_site_lbl, 2, Qt.AlignLeft)
for _ in range(nrof_controls):
pushbtn = QPushButton(self)
hbox3.addWidget(pushbtn)
self.push_ctl.append(pushbtn)
grid.addLayout(hbox3, 1, 2, 1, 1)
self.setLayout(grid)
# configure widgets
self.setContentsMargins(0, 0, 0, 0)
self.person_site_lbl.setObjectName("text") # use text style
self.calendar_notes_lbl.setObjectName("text")
self.calendar_notes_lbl.setAlignment(Qt.AlignCenter)
maximized = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
maximized.setHorizontalStretch(0)
maximized.setVerticalStretch(0)
self.setSizePolicy(maximized)
# self.site_view.setScaledContents(True)
model = QStringListModel()
# model.setStringList(self.forenames)
self.people_list.setModel(model)
self.people_list.setStyleSheet(style.people_list_style)
self.people_list.setEditTriggers(QListView.NoEditTriggers)
self.people_list.setProperty("showDropIndicator", False)
self.people_list.setDefaultDropAction(Qt.IgnoreAction)
selectionModel = QItemSelectionModel(model)
self.people_list.setSelectionModel(selectionModel)
self.setImage(world.locationImage(self.name))
# TODO: location buttons belong to a location
btn_size = (100, 35)
for text, pos in world.locationButtons(self.name):
pushbtn = QPushButton(self.site_view)
pushbtn.setGeometry(*pos, *btn_size)
pushbtn.setText(text)
pushbtn.setToolTip(text)
notice = self.site_view.addNotice(pushbtn)
notice.setFixedGeometry(True)
self.push_alt_views.append(pushbtn)
self.retranslateUi()
# connect signals
self.push_alt_views[0].clicked.connect(
self.parent().toggle_school_management)
selectionModel.selectionChanged.connect(self.on_selectionChanged)
self.site_view.show()
def addPerson(self, person):
self.ppl.append(person)
self.people_list.model().setStringList(self.forenames)
def removePerson(self, person):
pass # TODO
def setImage(self, path):
self.site_view.setPixmap(QPixmap(str(path)))
def retranslateUi(self):
tra = QApplication.translate
ctxt = "LocationView"
self.person_site_lbl.setText(tra(ctxt, "Oliver Klozoff | Lubriscity"))
self.calendar_notes_lbl.setText(
tra(ctxt, "No calendar notes for today"))
self.push_actions[0].setText(tra(ctxt, "Smartphone"))
self.push_actions[1].setText(tra(ctxt, "Inventory"))
self.push_actions[2].setText(tra(ctxt, "Map"))
self.push_ctl[0].setText(tra(ctxt, "Settings"))
self.push_ctl[1].setText(tra(ctxt, "Debug"))
btnnames = [data[0] for data in world.locationButtons(self.name)]
for btn, text in zip(self.push_alt_views, btnnames):
btn.setText(tra(ctxt, text))
@property
def forenames(self):
return [p.forename for p in self.ppl]
@pyqtSlot(QItemSelection, QItemSelection)
def on_selectionChanged(self, selected, deselected):
# TODO: implement blur
# self.site_view.toggle_blur()
# self.person_interact.setVisible(True)
self.person_interact.exec()
class GMDir:
EXT_WHITELIST = '.pdf'
@property
def path(self):
return self._path
@property
def documents(self):
return self._documents
@property
def name(self):
return self._name
@property
def tab_index(self):
return self._tab_index
@property
def closed(self):
return self._closed
@property
def open_count(self):
return self._open_count
@property
def unsaved_count(self):
return self._unsaved_count
def __init__(self, gm, path):
assert isinstance(gm, GalleryMark)
self._gm = gm
self._path = path
self._name = os.path.basename(path)
self._documents = []
self._open_count = 0
self._unsaved_count = 0
self._tab_index = None
self._tab_widget = None
self._listview = QListView()
self._listview.setViewMode(QListView.ListMode)
self._listview.setSelectionBehavior(QListView.SelectRows)
self._listview.activated.connect(self.onListViewItemActivated)
self._active_document = None
self._closed = False
self.refresh(init=True)
def refresh(self, init=False):
to_remove = []
for doc in self._documents:
if not os.path.exists(doc.path):
to_remove.append(doc)
for r in to_remove:
self._documents.remove(r)
for item in os.listdir(self._path):
full_path = os.path.join(self._path, item)
if os.path.isfile(full_path):
if item.lower().endswith(self.EXT_WHITELIST):
if init:
self._documents.append(GMDoc(full_path))
else:
found = False
for doc in self._documents:
if doc.path == full_path:
found = True
if not found:
self.documents.append(GMDoc(full_path))
if self._active_document is None and len(self._documents) > 0:
self.setActiveDocument(self._documents[0])
self.updateState()
if self._tab_widget is not None:
self._tab_widget.setTabText(self._tab_index, self.getTabName())
def onListViewItemActivated(self, model_index):
doc = model_index.data(Qt.UserRole)
self._gm.openDocument(doc)
self.updateState()
def updateState(self):
self._open_count = 0
self._unsaved_count = 0
model = QStandardItemModel()
for doc in self._documents:
item_text = doc.name
changed = doc.changed()
if changed:
item_text = '{}*'.format(item_text)
self._unsaved_count += 1
if self._active_document is not None and doc == self._active_document:
item_text = '> {}'.format(item_text)
self._open_count += 1
elif doc.is_open:
item_text = '+ {}'.format(item_text)
self._open_count += 1
item = QStandardItem(item_text)
item.setData(doc, Qt.UserRole)
item.setEditable(False)
model.appendRow(item)
self._listview.setModel(model)
def getDocumentByIndex(self, index):
if 0 <= index < len(self._documents):
mi = self._listview.model().index(index, 0)
self._listview.setCurrentIndex(mi)
return mi.data(Qt.UserRole)
return None
def setActiveDocument(self, doc):
self._active_document = doc
self.updateState()
def getPreviousDocument(self):
previous = None
if self._active_document is not None:
for i, doc in enumerate(self._documents):
if doc == self._active_document:
pi = i - 1
if pi >= 0:
previous = self._documents[pi]
return previous
def getNextDocument(self):
next = None
if self._active_document is not None:
for i, doc in enumerate(self._documents):
if doc == self._active_document:
ni = i + 1
if ni < len(self._documents):
next = self._documents[ni]
return next
def getTabName(self):
return '{} ({})'.format(self._name, len(self._documents))
def setupTab(self, tab_widget):
assert isinstance(tab_widget, QTabWidget)
container = QWidget()
layout = QVBoxLayout()
self.updateState()
layout.addWidget(self._listview)
container.setLayout(layout)
tab_widget.addTab(container, self.getTabName())
self._tab_index = tab_widget.indexOf(container)
self._tab_widget = tab_widget
def close(self, active_doc=None):
for doc in self._documents:
if active_doc is not None and doc == active_doc:
continue
if doc.is_open:
if not doc.close():
return False
self._closed = True
return True
