def __init__(self, filter_updater, parent=None):
"""
:type filter_updater: (str) -> None
:type parent: QWidget
"""
super().__init__(parent)
self._filter_updater = lambda: filter_updater(self.text())
self.setFixedHeight(self.HEIGHT)
self.setMaxLength(48)
self.setMaximumWidth(200)
self._tool_button = QToolButton(self)
self._tool_button.setIcon(QIcon(resource_filepath("clear.png")))
self._tool_button.setStyleSheet("QToolButton {"
" border: none;"
" padding: 0px;"
"}")
frame_width = self._getFrameWidth()
icon_side = self.HEIGHT - 2 * frame_width
self._tool_button.setFixedSize(icon_side, icon_side)
self._tool_button.clicked.connect(self.onClearButton)
self._tool_button.hide()
self.textChanged.connect(self.updateFilter)
stylesheet = \
"QLineEdit {{" \
" padding-right: {}px;" \
" background-color: #FFFFFF;" \
"}}".format(self._tool_button.sizeHint().width() + frame_width + 1)
self.setStyleSheet(stylesheet)
def create_header_bar(self, layout):
back_button = QToolButton()
back_button.setIconSize(QSize(30, 30))
back_button.setIcon(QIcon(os.path.join("icons", "ic_action_back.png")))
back_button.setStyleSheet("border: 0px;")
back_button.setToolTip("Zurück")
back_button.clicked.connect(self.back)
layout.addWidget(back_button)
def __init__(self, parent=None):
QLineEdit.__init__(self, parent)
self.clear_button = QToolButton(self)
self.clear_button.setText("clear")
self.clear_button.hide()
self.clear_button.clicked.connect(self.clear)
# self.clear_button.setIcon(QIcon(":/denied.png"))
self.textChanged.connect(self.update_clear_button)
def bookmark(self):
"""Toggle bookmark."""
global bookmarks
if not self.tabs.currentWidget().findChild(QFrame, unicode('pageWidget')).findChild(QWebView, unicode('webView')).url().toEncoded() in bookmarks:
bookmarks.append(self.tabs.currentWidget().findChild(QFrame, unicode('pageWidget')).findChild(QWebView, unicode('webView')).url().toEncoded())
pickle.dump(bookmarks, open(bookFile, "wb"))
link = QToolButton()
link.setDefaultAction(QAction(unicode(unicode(self.tabs.currentWidget().findChild(QFrame, unicode('pageWidget')).findChild(QWebView, unicode('webView')).url().toEncoded())), link))
link.setObjectName(unicode(self.tabs.currentWidget().findChild(QFrame, unicode('pageWidget')).findChild(QWebView, unicode('webView')).url().toEncoded()))
link.setFont(QFont("Helvetica Neue", 11, QFont.Normal))
link.clicked.connect(self.handleBookmarks)
self.bookmarks_layout.addWidget(link)
if self.bookmarks_widget.isHidden():
self.bookmarks_widget.show()
self.dbutton.setText(u"★")
else:
bookmarks.remove(self.tabs.currentWidget().findChild(QFrame, unicode('pageWidget')).findChild(QWebView, unicode('webView')).url().toEncoded())
pickle.dump(bookmarks, open(bookFile, "wb"))
link = self.bookmarks_widget.findChild(QToolButton, unicode(self.tabs.currentWidget().findChild(QFrame, unicode('pageWidget')).findChild(QWebView, unicode('webView')).url().toEncoded()))
self.bookmarks_layout.removeWidget(link)
link.deleteLater()
link = None
if not bookmarks:
self.bookmarks_widget.hide()
self.dbutton.setText(u"☆")
def createWidgets(self):
self.backButton = QToolButton()
self.backButton.setIcon(QIcon(":/go-back.svg"))
self.backButton.setText("&Back")
self.backButton.setToolTip("""\
<p><b>Back</b> ({})</p>
<p>Navigate to the previous page.</p>""".format(
QKeySequence("Alt+Left").toString()))
self.forwardButton = QToolButton()
self.forwardButton.setIcon(QIcon(":/go-forward.svg"))
self.forwardButton.setText("&Forward")
self.forwardButton.setToolTip("""\
<p><b>Forward</b> ({})</p>
<p>Navigate to the page you've just come back from.</p>""".format(
QKeySequence("Alt+Right").toString()))
self.contentsButton = QToolButton()
self.contentsButton.setIcon(QIcon(":/go-home.svg"))
self.contentsButton.setText("&Contents")
self.contentsButton.setToolTip("""\
<p><b>Contents</b> ({})</p>
<p>Navigate to the contents page.</p>""".format(
QKeySequence("Alt+Home").toString()))
self.searchLineEdit = Widgets.LegendLineEdit.LineEdit(
"Search (F3 or Ctrl+F)")
self.searchLineEdit.setToolTip("""\
<p><b>Search editor</p>
<p>Type in a word to search for in the online help pages and press
<b>Enter</b> or <b>F3</b> to search.</p>""")
self.zoomInButton = QToolButton()
self.zoomInButton.setIcon(QIcon(":/zoomin.svg"))
self.zoomInButton.setText("&Zoom In")
self.zoomInButton.setToolTip("""\
<p><b>Zoom In</b> ({})</p>
<p>Make the text bigger.</p>""".format(
QKeySequence("Alt++").toString()))
self.zoomOutButton = QToolButton()
self.zoomOutButton.setIcon(QIcon(":/zoomout.svg"))
self.zoomOutButton.setText("Zoom &Out")
self.zoomOutButton.setToolTip("""\
<p><b>Zoom Out</b> ({})</p>
<p>Make the text smaller.</p>""".format(
QKeySequence("Alt+-").toString()))
width = self.fontMetrics().width(self.zoomOutButton.text() + " ")
for button in (self.backButton, self.forwardButton,
self.contentsButton, self.zoomInButton,
self.zoomOutButton):
button.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
button.setMinimumWidth(width)
button.setFocusPolicy(Qt.NoFocus)
self.browser = QWebView()
page = self.browser.page()
page.setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
if self.debug:
self.urlLabel = QLabel()
def __init__(self, parent=None):
QToolButton.__init__(self, parent)
self.badge_counter = 0x00
self.badge_size = 25
self.redGradient = QRadialGradient(0.0, 0.0, 17.0, self.badge_size - 3,
self.badge_size - 3)
self.redGradient.setColorAt(0.0, QColor(0xe0, 0x84, 0x9b))
self.redGradient.setColorAt(0.5, QColor(0xe9, 0x34, 0x43))
self.redGradient.setColorAt(1.0, QColor(0xdc, 0x0c, 0x00))
def __init__(self, parent=None):
QToolButton.__init__(self, parent)
self.badge_counter = 0x00
self.badge_size = 25
self.redGradient = QRadialGradient(0.0, 0.0, 17.0, self.badge_size - 3,
self.badge_size - 3)
self.redGradient.setColorAt(0.0, QColor(0xe0, 0x84, 0x9b))
self.redGradient.setColorAt(0.5, QColor(0xe9, 0x34, 0x43))
self.redGradient.setColorAt(1.0, QColor(0xdc, 0x0c, 0x00))
def create_header_bar(self, layout):
back_button = QToolButton()
back_button.setIconSize(QSize(30, 30))
back_button.setIcon(QIcon(os.path.join("icons", "ic_action_back.png")))
back_button.setStyleSheet("border: 0px;")
back_button.setToolTip("Zurück")
back_button.clicked.connect(self.back)
layout.addWidget(back_button)
def _make_tabs_button(self, side_widgets, side_icons):
if len(side_widgets) != len(side_icons):
raise Exception(
"Bad parameters : len(side_widgets) ({}) != len(side_icons) ({})"
.format(len(side_widgets), len(side_icons)))
layout = QVBoxLayout()
self._side_icons = []
ndx = 0
for w in side_widgets:
resource_name = side_icons[ndx]
pixmap = QPixmap(os.path.join(resource_dir, resource_name))
icon = QIcon(pixmap)
self._side_icons.append(icon)
b = QToolButton()
b.setIcon(icon)
b.setIconSize(pixmap.rect().size())
b.setMaximumWidth(pixmap.rect().width() + 6)
b.clicked.connect(self.signal_mapper_tab_changed.map)
self.signal_mapper_tab_changed.setMapping(b, ndx)
layout.addWidget(b)
layout.setStretch(ndx, 1)
ndx += 1
layout.addStretch()
return layout
class Panel(QWidget):
def __init__(self, state, parent=None):
super().__init__(parent)
self.state = state
self.createWidgets()
self.layoutWidgets()
self.helpButton.clicked.connect(
lambda: self.state.help("xix_ref_panel_index.html"))
def clear(self):
self.view.clear()
def createWidgets(self):
self.indexLabel = QLabel("&Index ")
self.view = Views.All.View(self.state)
self.tooltips.append((self.view, """
<p><b>Index view</b> (Alt+I)</p>
<p>This view shows all the index's entries.</p>
<p>The entries are always shown in the correct order in accordance with
the the chosen <b>Index→Options, Rules, Calculate Sort As Rules</b>, so
there's never a need to explicitly sort.</p>"""))
self.indexLabel.setBuddy(self.view)
self.gotoLabel = QLabel("Goto <font color=darkgreen>(Ctrl+T)</font>")
self.gotoLineEdit = SelectAllLineEdit()
self.gotoLabel.setBuddy(self.gotoLineEdit)
self.tooltips.append((self.gotoLineEdit, """
<p><b>Goto (Ctrl+T)</b></p>
<p>Enter a few initial letters to goto the first main entry whose
term begins with those letters.</p>"""))
self.state.editors.add(self.gotoLineEdit)
self.helpButton = QToolButton()
self.helpButton.setIcon(QIcon(":/help.svg"))
self.helpButton.setFocusPolicy(Qt.NoFocus)
def layoutWidgets(self):
layout = QVBoxLayout()
hbox = QHBoxLayout()
hbox.addWidget(self.indexLabel)
hbox.addSpacing(self.fontMetrics().width("W") * 4)
hbox.addStretch()
hbox.addWidget(self.gotoLabel)
hbox.addWidget(self.gotoLineEdit, 1)
hbox.addWidget(self.helpButton)
layout.addLayout(hbox)
layout.addWidget(self.view, 1)
self.setLayout(layout)
def updateDisplayFonts(self):
self.view.updateDisplayFonts()
def paintEvent(self, event):
QToolButton.paintEvent(self, event)
p = QPainter(self)
p.setRenderHint(QPainter.TextAntialiasing)
p.setRenderHint(QPainter.Antialiasing)
if self.badge_counter > 0x00:
point = self.rect().topRight()
self.drawBadge(
p,
point.x() - self.badge_size,
point.y(),
self.badge_size,
str(self.badge_counter),
QBrush(self.redGradient),
)
def paintEvent(self, event):
QToolButton.paintEvent(self, event)
p = QPainter(self)
p.setRenderHint(QPainter.TextAntialiasing)
p.setRenderHint(QPainter.Antialiasing)
if self.badge_counter > 0x00:
point = self.rect().topRight()
self.drawBadge(
p,
point.x() - self.badge_size,
point.y(),
self.badge_size,
str(self.badge_counter),
QBrush(self.redGradient),
)
def createWidgets(self):
self.helpButton = QToolButton()
self.helpButton.setIcon(QIcon(":/help.svg"))
self.helpButton.setFocusPolicy(Qt.NoFocus)
self.helpButton.clicked.connect(self.help)
self.tooltips.append(
(self.helpButton,
"""Help on the Suggestions or Filtered panel."""))
self.view = Views.Filtered.View(self.state)
self.tooltips.append((self.view, """<p><b>Filtered view</b></p>
<p>This view shows any entries that match the current <b>Filter</b>.</p>
<p>Press <b>F3</b> or click <img src=":/goto-found.svg" width={0}
height={0}> or click <b>Goto→Filtered</b> to go to the current filtered
entry.</p>""".format(TOOLTIP_IMAGE_SIZE)))
self.view.match = ""
self.filterLabel = QLabel(
"Filter <font color=darkgreen>(Ctrl+F)</font>")
self.filterComboBox = QComboBox()
self.filterComboBox.setMaxVisibleItems(24)
self.tooltips.append((self.filterComboBox, """\
<p><b>Filter combobox</b></p>
<p>Use this combobox to choose the filter to use.</p>
<p>The <b>Terms Matching</b>, <b>Pages Matching</b>, and <b>Notes
Matching</b> filters need a match text.</p>"""))
self.filterLabel.setBuddy(self.filterComboBox)
for filter in FilterKind:
if not filter.isCheck:
self.filterComboBox.addItem(filter.text, filter)
self.filterComboBox.currentIndexChanged[int].connect(self.query)
self.filterTextComboBox = ComboBox()
self.filterTextComboBox.setEditable(True)
self.filterTextComboBox.setDuplicatesEnabled(False)
self.filterTextComboBox.currentIndexChanged[str].connect(self.setMatch)
self.tooltips.append((self.filterTextComboBox, """\
<p><b>Filter Match editor</b></p>
<p>The text to match when using a <b>Terms Matching</b>, <b>Pages
Matching</b>, or <b>Notes Matching</b> filter.</p>
<p>For terms and notes, the filtered entries are chosen by
case-insensitively comparing with the match word or words.</p> <p>Add a
<tt>*</tt> after a word to match any words that begin with the text
preceding the <tt>*</tt>.</p> <p>For example, “comp*” will match
“compress”, “compulsory”, “computer”, “computed”, etc.</p>
<p>For pages, enter them as you would for an entry's pages, e.g.,
<tt>199,202-5</tt> to match entries whose pages equal or include
<tt>199,202,203,204,205</tt>, whether explicitly, or within page
ranges.</p>"""))
self.view.pane.clickLine.connect(self.state.updateNavigationStatus)
def create_header_bar(self, layout):
self.sync_button = QToolButton()
self.sync_button.setIconSize(QSize(30, 30))
self.sync_button.setIcon(QIcon(os.path.join("icons", "ic_action_sync.png")))
self.sync_button.setStyleSheet("border: 0px;")
self.sync_button.setToolTip("Sync")
self.sync_button.clicked.connect(self.sync_clicked)
self.sync_button.setVisible(False)
layout.addWidget(self.sync_button)
self.clipboard_button = QToolButton()
self.clipboard_button.setIconSize(QSize(30, 30))
self.clipboard_button.setIcon(QIcon(os.path.join("icons", "ic_action_copy.png")))
self.clipboard_button.setStyleSheet("border: 0px;")
self.clipboard_button.setToolTip("in die Zwischenablage")
self.clipboard_button.clicked.connect(self.copy_to_clipboard)
self.clipboard_button.setVisible(False)
layout.addWidget(self.clipboard_button)
def createWidgets(self):
self.label = QLabel("Gro&ups")
self.groupsList = QListWidget()
self.tooltips.append((self.groupsList, """
<p><b>Groups</b> (Alt+U)</p>
<p>A (possibly empty) list of the current entry's groups.</p>"""))
self.label.setBuddy(self.groupsList)
self.closeButton = QToolButton()
self.closeButton.setIcon(QIcon(":/hide.svg"))
self.closeButton.setFocusPolicy(Qt.NoFocus)
self.tooltips.append((self.closeButton, """<p><b>Hide</b></p>
<p>Hide the Groups panel.</p>
<p>Use <b>Spelling→Show Suggestions and Groups</b> to show it
again.</p>"""))
self.helpButton = QToolButton()
self.helpButton.setIcon(QIcon(":/help.svg"))
self.helpButton.setFocusPolicy(Qt.NoFocus)
self.tooltips.append((self.helpButton, "Help on the Groups panel."))
def make_tool_button(filename, name=None):
res_path = os.path.join(resource_dir, filename)
if filename not in resources_cache:
if not os.path.exists(res_path):
raise Exception("Can't find resource {}".format(res_path))
pixmap = QPixmap(res_path)
icon = QIcon(pixmap)
resources_cache[filename] = (pixmap, icon)
pixmap, icon = resources_cache[filename]
b = QToolButton()
b.setIcon(icon)
b.setIconSize(pixmap.rect().size())
b.setMaximumWidth(pixmap.rect().width()) # 6
if name:
b.setObjectName(name)
return b
def createWidgets(self):
self.label = QLabel("Suggestions")
self.spellList = Widgets.List.HtmlListWidget(self.state)
self.tooltips.append((self.spellList, """
<p><b>Suggestions</b> (Alt+N,Tab)</p>
<p>A (possibly empty) list of completions or replacements for the word
being typed in the <b>Term</b> editor.</p>"""))
self.label.setBuddy(self.spellList)
self.closeButton = QToolButton()
self.closeButton.setIcon(QIcon(":/hide.svg"))
self.closeButton.setFocusPolicy(Qt.NoFocus)
self.tooltips.append((self.closeButton, """<p><b>Hide</b></p>
<p>Hide the Suggestions panel.</p>
<p>Use <b>Spelling→Show Suggestions and Groups</b> to show it
again.</p>"""))
self.helpButton = QToolButton()
self.helpButton.setIcon(QIcon(":/help.svg"))
self.helpButton.setFocusPolicy(Qt.NoFocus)
self.tooltips.append(
(self.helpButton, "Help on the Suggestions panel."))
def createWidgets(self):
self.indexLabel = QLabel("&Index ")
self.view = Views.All.View(self.state)
self.tooltips.append((self.view, """
<p><b>Index view</b> (Alt+I)</p>
<p>This view shows all the index's entries.</p>
<p>The entries are always shown in the correct order in accordance with
the the chosen <b>Index→Options, Rules, Calculate Sort As Rules</b>, so
there's never a need to explicitly sort.</p>"""))
self.indexLabel.setBuddy(self.view)
self.gotoLabel = QLabel("Goto <font color=darkgreen>(Ctrl+T)</font>")
self.gotoLineEdit = SelectAllLineEdit()
self.gotoLabel.setBuddy(self.gotoLineEdit)
self.tooltips.append((self.gotoLineEdit, """
<p><b>Goto (Ctrl+T)</b></p>
<p>Enter a few initial letters to goto the first main entry whose
term begins with those letters.</p>"""))
self.state.editors.add(self.gotoLineEdit)
self.helpButton = QToolButton()
self.helpButton.setIcon(QIcon(":/help.svg"))
self.helpButton.setFocusPolicy(Qt.NoFocus)
def show_calorie_calc(self, row_count=0):
'''
show calorie calculator
:return:
'''
if row_count > 0:
row_count += 1
self.clear_table(None, None)
self.stuff_table.clearContents()
self.stuff_table.setColumnCount(3)
self.stuff_table.setRowCount(row_count)
self.stuff_table.setHorizontalHeaderLabels(['Amount', 'Unit', 'Name'])
if row_count > 0:
stuff_widget = QWidget()
stuff_pixmap = QPixmap('icons/add.png')
stuff_icon = QIcon()
stuff_add_bt = QToolButton()
stuff_icon.addPixmap(stuff_pixmap)
stuff_add_bt.setIcon(stuff_icon)
stuff_add_bt.setIconSize(QSize(8, 8))
stuff_add_bt.clicked.connect(
lambda: self.stuff_table.insertRow(row_count - 1))
stuff_layout = QHBoxLayout()
stuff_layout.addWidget(stuff_add_bt)
stuff_widget.setLayout(stuff_layout)
self.stuff_table.setCellWidget(row_count - 1, 2, stuff_widget)
def editTab(self):
self.eFileTable = QTableView()
self.eFileTable.setModel(self.eFileModel)
self.eFileTable.setSelectionBehavior(QAbstractItemView.SelectRows)
self.setColumnsWidths(self.eFileTable)
self.editWidget = QWidget()
vLayout = QVBoxLayout()
vLayout.addWidget(self.eFileTable)
dropBtn = QToolButton()
dropBtn.setDefaultAction(self.dropEditTabAct)
undBtn = QPushButton("Undo Delete")
undBtn.clicked.connect(self.undeleteFiles)
rmvBtn = QPushButton("Delete")
rmvBtn.clicked.connect(self.deleteFiles)
cmtBtn = QPushButton("Update")
cmtBtn.clicked.connect(self.update)
hLayout = QHBoxLayout()
hLayout.addWidget(dropBtn)
hLayout.addStretch(1)
hLayout.addWidget(undBtn)
hLayout.addWidget(rmvBtn)
hLayout.addWidget(cmtBtn)
vLayout.addLayout(hLayout)
self.editWidget.setLayout(vLayout)
self.tabWidget.addTab(self.editWidget, u"Edit")
def __init__(self, parent=None):
super(SearchEdit, self).__init__(parent)
clr_pixmap = QPixmap(':/icons/clear.png')
self._btn_clear = QToolButton(self)
self._btn_clear.setIcon(clr_pixmap)
self._btn_clear.setIconSize(clr_pixmap.size())
self._btn_clear.setCursor(Qt.ArrowCursor)
self._btn_clear.setStyleSheet('QToolButton { border: none; padding: 0px; }');
self._btn_clear.clicked.connect(self.clear)
fw = self.style().pixelMetric(QStyle.PM_DefaultFrameWidth)
#TODO: Make a Search glyph show up properly
self.setStyleSheet('QLineEdit { padding-right: %dpx; }' % (self._btn_clear.sizeHint().width() + fw + 1))
msz = self.minimumSizeHint()
self.setMinimumSize(max([msz.width(), self._btn_clear.sizeHint().height() + fw * 2 + 2]),
max([msz.height(), self._btn_clear.sizeHint().height() + fw * 2 + 2]))
self.setPlaceholderText('Search')
class LabelFilterEdit(QLineEdit):
clear_button = None
def __init__(self, parent=None):
QLineEdit.__init__(self, parent)
self.clear_button = QToolButton(self)
self.clear_button.setText("clear")
self.clear_button.hide()
self.clear_button.clicked.connect(self.clear)
# self.clear_button.setIcon(QIcon(":/denied.png"))
self.textChanged.connect(self.update_clear_button)
def resizeEvent(self, *args, **kwargs):
super(LabelFilterEdit, self).resizeEvent(*args, **kwargs)
sz = self.clear_button.sizeHint()
frameWidth = 0 #self.style().pixelMetric(QStyle.PM_DefaultFrameWidth)
self.clear_button.move(self.rect().right() - sz.width() - frameWidth,
(self.rect().bottom() + 1 - sz.height()) / 2)
def update_clear_button(self, text):
self.clear_button.setVisible(len(text)>0)
def setup_ui(self):
main_layout = QHBoxLayout(self)
edt = QLineEdit(self)
edt.setPlaceholderText("Wildcard filter")
btn = QToolButton(self)
btn.clicked.connect(self.set_icon)
layout = QHBoxLayout(self)
layout.addWidget(edt)
layout.addWidget(btn)
layout2 = QVBoxLayout()
layout2.addLayout(layout)
model = TListModel(self)
proxy = QSortFilterProxyModel(self)
proxy.setFilterCaseSensitivity(Qt.CaseInsensitive)
proxy.setSourceModel(model)
edt.textChanged.connect(proxy.setFilterWildcard)
list = QListView()
list.setModel(proxy)
selection_model = list.selectionModel()
selection_model.currentChanged.connect(self.currentChanged)
layout2.addWidget(list)
main_layout.addLayout(layout2)
image = QLabel("Select icon", self)
image.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
image.setMinimumWidth(256)
main_layout.addWidget(image)
self.btn = btn
self.edt = edt
self.image = image
self.list = list
self.proxy = proxy
self.model = model
self.selection_model = selection_model
def addTab(self):
self.aFileTable = QTableView()
self.aFileTable.setModel(self.aFileModel)
self.aFileTable.setSelectionBehavior(QAbstractItemView.SelectRows)
self.setColumnsWidths(self.aFileTable)
self.addWidget = QWidget()
vLayout = QVBoxLayout()
vLayout.addWidget(self.aFileTable)
addBtn = QToolButton()
addBtn.setDefaultAction(self.findAct)
# addBtn.clicked.connect(self.findFilesDlg)
dropBtn = QToolButton()
dropBtn.setDefaultAction(self.dropAddTabAct)
# rmvBtn.clicked.connect(self.rmvFiles)
insBtn = QPushButton("Track")
insBtn.clicked.connect(self.insert)
hLayout = QHBoxLayout()
hLayout.addWidget(addBtn)
hLayout.addWidget(dropBtn)
hLayout.addStretch(1)
hLayout.addWidget(insBtn)
vLayout.addLayout(hLayout)
self.addWidget.setLayout(vLayout)
self.tabWidget.addTab(self.addWidget, u"Add")
def CreateFlatButton(action):
"""
Create a custom flat button and style
it so that it will look good on all platforms.
"""
toolButton = QToolButton()
toolButton.setIcon(action.icon())
toolButton.setText(action.text())
toolButton.setAutoRaise(True)
toolButton.setIconSize(QSize(32, 32))
toolButton.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
if sys.platform.startswith('darwin'):
# Bug for Mac: QToolButtons do not react to setAutoRaise so
# can't be made flat when they are not used inside a toolbar.
# Setting a custom style sheet with border to none fixes this.
# But then it looses all its highlight and pressed visual cues
# so some extra styling needs to be done to provide some nice
# visual feedback on hover and pressed states.
toolButton.setStyleSheet("QToolButton {"
"border: none;"
"} "
"QToolButton:hover {"
"background-color: qradialgradient(cx: 0.5, cy: 0.5,"
"fx: 0.5, fy: 0.5,"
"radius: 0.5, "
"stop: 0 rgba(255, 255, 255, 100), "
"stop: 1 rgba(0, 0, 0, 0));"
"}"
"QToolButton:pressed {"
"background-color: qradialgradient(cx: 0.5, cy: 0.5,"
"fx: 0.5, fy: 0.5,"
"radius: 0.5, "
"stop: 0 rgba(255, 255, 255, 200), "
"stop: 1 rgba(0, 0, 0, 0));"
"}")
font = QFont()
font.setPixelSize(10)
toolButton.setFont(font)
# Connect the clicked signal to the action trigger
def pushed():
toolButton.action.triggered.emit()
setattr(toolButton, "pushed", pushed)
toolButton.clicked.connect(toolButton.pushed)
setattr(toolButton, "action", action)
return toolButton
def setupUi(self, MainWindow):
lbMinWidth = 65
# leMinWidth = 200
MainWindow.setObjectName("MainWindow")
MainWindow.resize(400, 310)
# self.centralwidget = QWidget(MainWindow)
self.mainSplitter = QSplitter(Qt.Horizontal, MainWindow)
self.mainSplitter.setObjectName("centralwidget")
self.mainSplitter.setProperty("childrenCollapsible", False)
MainWindow.setCentralWidget(self.mainSplitter)
self.leftSplitter = QSplitter(Qt.Vertical, self.mainSplitter)
self.leftSplitter.setProperty("childrenCollapsible", False)
##### login_gbox
self.login_gbox = QGroupBox(self.leftSplitter)
self.login_gbox.setFlat(True)
self.login_gbox.setObjectName("login_gbox")
login_gbox_layout = QVBoxLayout(self.login_gbox)
login_gbox_csf_layout = QHBoxLayout()
login_gbox_account_layout = QHBoxLayout()
login_gbox_connect_layout = QHBoxLayout()
login_gbox_layout.addLayout(login_gbox_csf_layout)
login_gbox_layout.addLayout(login_gbox_account_layout)
login_gbox_layout.addLayout(login_gbox_connect_layout)
self.lb_client_secrets_file_path = QLabel(self.login_gbox)
self.lb_client_secrets_file_path.setObjectName("lb_client_secrets_file_path")
self.lb_client_secrets_file_path.setMinimumWidth(lbMinWidth)
self.client_secrets_file_path_le = QLineEdit(self.login_gbox)
self.client_secrets_file_path_le.setObjectName("client_secrets_file_path_le")
self.client_secret_file_path_tBtn = QToolButton(self.login_gbox)
self.client_secret_file_path_tBtn.setObjectName("client_secret_file_path_tBtn")
login_gbox_csf_layout.addWidget(self.lb_client_secrets_file_path)
login_gbox_csf_layout.addWidget(self.client_secrets_file_path_le)
login_gbox_csf_layout.addWidget(self.client_secret_file_path_tBtn)
self.lb_account = QLabel(self.login_gbox)
self.lb_account.setMaximumWidth(lbMinWidth)
self.lb_account.setObjectName("lb_account")
self.remove_account_btn = QToolButton(self.login_gbox)
self.remove_account_btn.setObjectName("remove_account_btn")
self.remove_account_btn.setMinimumWidth(20)
self.remove_account_btn.setEnabled(False)
self.add_account_btn = QToolButton(self.login_gbox)
self.add_account_btn.setObjectName("add_account_btn")
self.add_account_btn.setMinimumWidth(20)
self.accounts_cb = QComboBox(self.login_gbox)
self.accounts_cb.setObjectName("accounts_cb")
login_gbox_account_layout.addWidget(self.lb_account)
login_gbox_account_layout.addWidget(self.remove_account_btn)
login_gbox_account_layout.addWidget(self.add_account_btn)
login_gbox_account_layout.addWidget(self.accounts_cb)
self.lb_decryption_key = QLabel(self.login_gbox)
self.lb_decryption_key.setObjectName("lb_decryption_key")
self.lb_decryption_key.setMinimumWidth(lbMinWidth)
self.lb_decryption_key.hide()
self.decryption_key_le = QLineEdit(self.login_gbox)
self.decryption_key_le.setEchoMode(QLineEdit.Password)
self.decryption_key_le.setObjectName("decryption_key_le")
self.decryption_key_le.hide()
self.connect_btn = QPushButton(self.login_gbox)
self.connect_btn.setEnabled(False)
self.connect_btn.setObjectName("connect_btn")
login_gbox_connect_layout.addWidget(self.lb_decryption_key)
login_gbox_connect_layout.addWidget(self.decryption_key_le)
login_gbox_connect_layout.addWidget(self.connect_btn)
#### search_gbox
self.search_gbox = QGroupBox(self.leftSplitter)
self.search_gbox.setFlat(True)
self.search_gbox.setObjectName("search_gbox")
self.search_gbox.hide()
search_gbox_layout = QVBoxLayout(self.search_gbox)
search_gbox_mailbox_layout = QVBoxLayout()
search_gbox_date_layout = QHBoxLayout()
search_gbox_from_layout = QHBoxLayout()
search_gbox_to_layout = QHBoxLayout()
search_gbox_subject_layout = QHBoxLayout()
search_gbox_threads_layout = QHBoxLayout()
search_gbox_paramaters_layout = QHBoxLayout()
search_gbox_layout.addLayout(search_gbox_mailbox_layout)
search_gbox_layout.addLayout(search_gbox_date_layout)
search_gbox_layout.addLayout(search_gbox_from_layout)
search_gbox_layout.addLayout(search_gbox_to_layout)
search_gbox_layout.addLayout(search_gbox_subject_layout)
search_gbox_layout.addLayout(search_gbox_threads_layout)
search_gbox_layout.addLayout(search_gbox_paramaters_layout)
self.lb_select_mailbox = QLabel(self.search_gbox)
self.lb_select_mailbox.setObjectName("lb_select_mailbox")
self.mailboxes_lw = QListWidget(self.search_gbox)
self.mailboxes_lw.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.mailboxes_lw.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.mailboxes_lw.setObjectName("mailboxes_lw")
search_gbox_mailbox_layout.addWidget(self.lb_select_mailbox)
search_gbox_mailbox_layout.addWidget(self.mailboxes_lw)
self.after_date_cb = QCheckBox(self.search_gbox)
self.after_date_cb.setObjectName("after_date_cb")
self.after_date_cb.setMinimumWidth(lbMinWidth)
self.after_date_cb.setMaximumWidth(lbMinWidth)
self.after_date_edit = QDateEdit(self.search_gbox)
self.after_date_edit.setCalendarPopup(True)
self.after_date_edit.setObjectName("after_date_edit")
self.after_date_edit.setDate(QDate.currentDate().addDays(-365))
self.after_date_edit.setMaximumDate(QDate.currentDate())
self.after_date_edit.setEnabled(False)
self.before_date_cb = QCheckBox(self.search_gbox)
self.before_date_cb.setObjectName("before_date_cb")
self.before_date_cb.setMinimumWidth(70)
self.before_date_cb.setMaximumWidth(70)
self.before_date_edit = QDateEdit(self.search_gbox)
self.before_date_edit.setCalendarPopup(True)
self.before_date_edit.setObjectName("before_date_edit")
self.before_date_edit.setDate(QDate.currentDate())
self.before_date_edit.setMaximumDate(QDate.currentDate())
self.before_date_edit.setEnabled(False)
search_gbox_date_layout.addWidget(self.after_date_cb)
search_gbox_date_layout.addWidget(self.after_date_edit)
search_gbox_date_layout.addWidget(self.before_date_cb)
search_gbox_date_layout.addWidget(self.before_date_edit)
self.lb_from = QLabel(self.search_gbox)
self.lb_from.setObjectName("lb_from")
self.lb_from.setMinimumWidth(lbMinWidth)
self.from_le = QLineEdit(self.search_gbox)
self.from_le.setObjectName("from_le")
search_gbox_from_layout.addWidget(self.lb_from)
search_gbox_from_layout.addWidget(self.from_le)
self.lb_to = QLabel(self.search_gbox)
self.lb_to.setObjectName("lb_to")
self.lb_to.setMinimumWidth(lbMinWidth)
self.to_le = QLineEdit(self.search_gbox)
self.to_le.setObjectName("to_le")
search_gbox_to_layout.addWidget(self.lb_to)
search_gbox_to_layout.addWidget(self.to_le)
self.lb_subject = QLabel(self.search_gbox)
self.lb_subject.setObjectName("lb_subject")
self.lb_subject.setMinimumWidth(lbMinWidth)
self.subject_le = QLineEdit(self.search_gbox)
self.subject_le.setObjectName("subject_le")
search_gbox_subject_layout.addWidget(self.lb_subject)
search_gbox_subject_layout.addWidget(self.subject_le)
self.lb_threads = QLabel(self.search_gbox)
self.lb_threads.setObjectName("lb_threads")
self.lb_threads.setMaximumWidth(lbMinWidth)
self.thread_count_sb = QSpinBox(self.search_gbox)
self.thread_count_sb.setMinimum(1)
self.thread_count_sb.setMaximum(10)
self.thread_count_sb.setObjectName("thread_count_sb")
self.html_radio = QRadioButton(self.search_gbox)
self.html_radio.setObjectName("html_radio")
self.text_radio = QRadioButton(self.search_gbox)
self.text_radio.setObjectName("text_radio")
self.extactTypeButtonGroup = QButtonGroup(self)
self.extactTypeButtonGroup.addButton(self.html_radio)
self.extactTypeButtonGroup.addButton(self.text_radio)
self.html_radio.setChecked(True)
self.search_btn = QPushButton(self.search_gbox)
self.search_btn.setObjectName("search_btn")
search_gbox_threads_layout.addWidget(self.lb_threads)
search_gbox_threads_layout.addWidget(self.thread_count_sb)
search_gbox_threads_layout.addWidget(self.html_radio)
search_gbox_threads_layout.addWidget(self.text_radio)
search_gbox_threads_layout.addWidget(self.search_btn)
self.parameters_cb = QCheckBox(self.search_gbox)
self.parameters_cb.setText("")
self.parameters_cb.setObjectName("parameters_cb")
self.parameters_le = QLineEdit(self.search_gbox)
self.parameters_le.setEnabled(False)
self.parameters_le.setObjectName("parameters_le")
search_gbox_paramaters_layout.addWidget(self.parameters_cb)
search_gbox_paramaters_layout.addWidget(self.parameters_le)
#### log_gbox
self.log_gbox = QGroupBox(self.leftSplitter)
self.log_gbox.setFlat(True)
self.log_gbox.setObjectName("log_gbox")
log_layout = QVBoxLayout(self.log_gbox)
self.log_te = QTextEdit(self.log_gbox)
self.log_te.setLineWrapMode(QTextEdit.NoWrap)
self.log_te.setReadOnly(True)
self.log_te.setTextInteractionFlags(Qt.TextSelectableByKeyboard | Qt.TextSelectableByMouse)
self.log_te.setObjectName("log_te")
self.disconnect_btn = QPushButton(self.log_gbox)
self.disconnect_btn.setObjectName("disconnect_btn")
self.disconnect_btn.hide()
log_layout.addWidget(self.log_te)
log_layout_btn = QHBoxLayout()
log_layout.addLayout(log_layout_btn)
log_layout_btn.addWidget(self.disconnect_btn)
log_layout_btn.addStretch()
#### links_gbox
self.links_gbox = QGroupBox(self.mainSplitter)
self.links_gbox.setFlat(True)
self.links_gbox.setObjectName("links_gbox")
self.links_gbox.hide()
links_gbox_layout = QVBoxLayout(self.links_gbox)
links_gbox_links_layout = QVBoxLayout()
links_gbox_buttons_layout = QHBoxLayout()
links_gbox_layout.addLayout(links_gbox_links_layout)
links_gbox_layout.addLayout(links_gbox_buttons_layout)
self.links_text_edit = QTextEdit(self.links_gbox)
self.links_text_edit.setObjectName("links_text_edit")
links_gbox_links_layout.addWidget(self.links_text_edit)
self.export_txt_btn = QPushButton(self.links_gbox)
self.export_txt_btn.setObjectName("export_txt_btn")
self.export_txt_btn.setEnabled(False)
self.export_html_btn = QPushButton(self.links_gbox)
self.export_html_btn.setObjectName("export_html_btn")
self.export_html_btn.setEnabled(False)
links_gbox_buttons_layout.addWidget(self.export_txt_btn)
links_gbox_buttons_layout.addWidget(self.export_html_btn)
### menubar
self.menubar = QMenuBar(MainWindow)
# self.menubar.setGeometry(QRect(0, 0, 860, 21))
self.menubar.setObjectName("menubar")
self.menu_file = QMenu(self.menubar)
self.menu_file.setObjectName("menu_file")
self.menu_help = QMenu(self.menubar)
self.menu_help.setObjectName("menu_help")
MainWindow.setMenuBar(self.menubar)
self.action_about = QAction(MainWindow)
self.action_about.setObjectName("action_about")
self.action_About_Qt = QAction(MainWindow)
self.action_About_Qt.setObjectName("action_About_Qt")
self.action_exit = QAction(MainWindow)
self.action_exit.setObjectName("action_exit")
self.actionSave = QAction(MainWindow)
self.actionSave.setObjectName("actionSave")
self.action_Gmail_Advanced_Search_Syntax = QAction(MainWindow)
self.action_Gmail_Advanced_Search_Syntax.setObjectName("action_Gmail_Advanced_Search_Syntax")
self.menu_file.addAction(self.action_exit)
self.menu_help.addAction(self.action_Gmail_Advanced_Search_Syntax)
self.menu_help.addSeparator()
self.menu_help.addAction(self.action_about)
self.menu_help.addAction(self.action_About_Qt)
self.menubar.addAction(self.menu_file.menuAction())
self.menubar.addAction(self.menu_help.menuAction())
self.retranslateUi(MainWindow)
QMetaObject.connectSlotsByName(MainWindow)
MainWindow.setTabOrder(self.client_secrets_file_path_le, self.client_secret_file_path_tBtn)
MainWindow.setTabOrder(self.client_secret_file_path_tBtn, self.remove_account_btn)
MainWindow.setTabOrder(self.remove_account_btn, self.add_account_btn)
MainWindow.setTabOrder(self.add_account_btn, self.accounts_cb)
MainWindow.setTabOrder(self.decryption_key_le, self.connect_btn)
MainWindow.setTabOrder(self.connect_btn, self.log_te)
MainWindow.setTabOrder(self.log_te, self.mailboxes_lw)
MainWindow.setTabOrder(self.mailboxes_lw, self.after_date_cb)
MainWindow.setTabOrder(self.after_date_cb, self.after_date_edit)
MainWindow.setTabOrder(self.after_date_edit, self.before_date_cb)
MainWindow.setTabOrder(self.before_date_cb, self.before_date_edit)
MainWindow.setTabOrder(self.before_date_edit, self.from_le)
MainWindow.setTabOrder(self.from_le, self.to_le)
MainWindow.setTabOrder(self.to_le, self.subject_le)
MainWindow.setTabOrder(self.subject_le, self.thread_count_sb)
MainWindow.setTabOrder(self.thread_count_sb, self.html_radio)
MainWindow.setTabOrder(self.html_radio, self.text_radio)
MainWindow.setTabOrder(self.text_radio, self.search_btn)
MainWindow.setTabOrder(self.search_btn, self.parameters_cb)
MainWindow.setTabOrder(self.parameters_cb, self.parameters_le)
MainWindow.setTabOrder(self.parameters_le, self.disconnect_btn)
MainWindow.setTabOrder(self.disconnect_btn, self.links_text_edit)
MainWindow.setTabOrder(self.links_text_edit, self.export_txt_btn)
MainWindow.setTabOrder(self.export_txt_btn, self.export_html_btn)
MainWindow.setTabOrder(self.export_html_btn, self.mailboxes_lw)
class MDISubWindow_TextEdit(QTextEdit):
documentCount = 1
def __init__(self, parent=None, filePath=''):
"""Default class constructor."""
super(MDISubWindow_TextEdit, self).__init__(parent)
print(filePath)
self.filePath = filePath
self.fileName = os.path.basename(os.path.abspath(filePath))
self.fileExt = os.path.splitext(self.fileName)[1]
if not filePath:
self.setWindowTitle('Untitled[*]')
parent.setWindowIcon(QIcon(gIconDir + os.sep + 'new.png'))
else:
f = open(filePath, 'r')
txt = f.read()
f.close()
self.setText(txt)
self.setWindowTitle('%s[*]' % self.fileName)
# TODO: This is changing all the subwindows icons. We want individual icons based on filetype...?
if self.fileExt in ('.py', '.pyw'):
parent.setWindowIcon(QIcon(gIconDir + os.sep + 'pyscript.png'))
else:
parent.setWindowIcon(QIcon(gIconDir + os.sep + 'new.png'))
monoFont = QFont('Courier New')
monoFont.setFixedPitch(True)
self.setFont(monoFont)
self.setWordWrapMode(QTextOption.NoWrap)
## self.setTextBackgroundColor(QColor('#000000'))
## self.setTextColor(QColor('#FFFFFF'))
self.setCursorWidth(2)
self.CreateActions()
self.zoomLevel = 0
gMainWin.action_Edit_Cut.setEnabled(False)
gMainWin.action_Edit_Copy.setEnabled(False)
self.copyAvailable.connect(gMainWin.action_Edit_Cut.setEnabled)
self.copyAvailable.connect(gMainWin.action_Edit_Copy.setEnabled)
# Handle the Context Menu Entries Also.
self.action_Edit_Undo.setEnabled(False)
self.action_Edit_Redo.setEnabled(False)
self.action_Edit_Cut.setEnabled(False)
self.action_Edit_Copy.setEnabled(False)
self.undoAvailable.connect(self.action_Edit_Undo.setEnabled)
self.redoAvailable.connect(self.action_Edit_Redo.setEnabled)
self.copyAvailable.connect(self.action_Edit_Cut.setEnabled)
self.copyAvailable.connect(self.action_Edit_Copy.setEnabled)
self.document().contentsChanged.connect(self.TheDocumentWasModified)
# self.show()
# self.showMaximized()
# self.setFocusPolicy(Qt.WheelFocus)
##### self.setFocus() # This makes the MDIArea go into SubWindowView...?
self.gCornerWidget = QToolButton(self)
# self.gCornerWidgetToolTip = QToolTip()
QToolTip.setFont(QFont('SansSerif', 10))
br = QBrush(QPixmap(gImgDir + os.sep + 'texture-spirals.png'))
pal = QPalette()
# pal.setBrush(QPalette.Active, QPalette.Base, br)
# pal.setColor(QPalette.Background, QColor('#FF8000'))
pal.setColor(QPalette.ColorGroup.Inactive,
QPalette.ColorRole.ToolTipBase,
QColor(EMBROIDERBLUE2))
QToolTip.setPalette(QPalette(pal))
self.action_Edit_SelectAll.setToolTip('This is a <b>QWidget</b> widget')
self.gCornerWidget.setDefaultAction(self.action_Edit_SelectAll)
self.setCornerWidget(self.gCornerWidget)
# We want to show the corner widget no matter what so...
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
def CreateActions(self):
self.action_Edit_Undo = QAction(QIcon(gIconDir + os.sep + 'undo.png'),
self.tr('&Undo'), self,
shortcut=UndoShortcut, # QKeySequence.Undo
statusTip=self.tr('Reverses the most recent action.'),
triggered=self.undo)
self.action_Edit_Redo = QAction(QIcon(gIconDir + os.sep + 'redo.png'),
self.tr('&Redo'), self,
shortcut=RedoShortcut, # QKeySequence.Redo
statusTip=self.tr('Reverses the effects of the previous undo action.'),
triggered=self.redo)
self.action_Edit_Cut = QAction(QIcon(gIconDir + os.sep + 'cut.png'),
self.tr('Cu&t'), self,
shortcut=CutShortcut, # QKeySequence.Cut
statusTip=self.tr('Cut the current selection\'s contents to the clipboard.'),
triggered=self.cut)
self.action_Edit_Copy = QAction(QIcon(gIconDir + os.sep + 'copy.png'),
self.tr('&Copy'), self,
shortcut=CopyShortcut, # QKeySequence.Copy
statusTip=self.tr('Copy the current selection\'s contents to the clipboard.'),
triggered=self.copy)
self.action_Edit_Paste = QAction(QIcon(gIconDir + os.sep + 'paste.png'),
self.tr('&Paste'), self,
shortcut=PasteShortcut, # QKeySequence.Paste
statusTip=self.tr('Paste the clipboard\'s contents into the current selection.'),
triggered=self.paste)
self.action_Edit_Delete = QAction(QIcon(gIconDir + os.sep + 'delete.png'),
self.tr('&Delete'), self,
# shortcut=DeleteShortcut, # QKeySequence.Delete
statusTip=self.tr('Delete selection.'),
triggered=gMainWin.OnTODO)
# triggered=self.delete)
self.action_Edit_SelectAll = QAction(QIcon(gIconDir + os.sep + 'selectall.png'),
self.tr('&Select All'), self,
# shortcut=SelectAllShortcut, # QKeySequence.SelectAll
statusTip=self.tr('Select all text in the document.'),
# toolTip=QToolTip.text('Select All'),
triggered=self.selectAll)
self.action_Edit_ZoomIn = QAction(QIcon(gIconDir + os.sep + 'zoomin.png'),
self.tr('Zoom &In'), self,
shortcut=QKeySequence.ZoomIn, # ZoomInShortcut,
statusTip=self.tr('Zoom In'),
triggered=self.DoZoomIn)
self.action_Edit_ZoomOut = QAction(QIcon(gIconDir + os.sep + 'zoomout.png'),
self.tr('Zoom &Out'), self,
shortcut=QKeySequence(Qt.CTRL + Qt.Key_Plus), #QKeySequence.ZoomOut, # ZoomOutShortcut,
statusTip=self.tr('Zoom Out'),
triggered=self.DoZoomOut)
self.action_Edit_ZoomDefault = QAction(QIcon(gIconDir + os.sep + 'zoom.png'),
self.tr('Zoom &Default'), self,
shortcut=ZoomDefaultShortcut,
statusTip=self.tr('Zoom Default'),
triggered=self.DoZoomDefault)
def TheDocumentWasModified(self):
""""""
self.setWindowModified(self.document().isModified())
# def focusInEvent(self, event):
# event.accept()
# event.ignore()
# print('focusInEvent - ')
def AskToSaveBeforeClosing(self):
""""""
if self.document().isModified():
ret = QMessageBox.warning(self, 'Warning',
'The document has been modified.' '\n'
'Do you want to save your changes?',
QMessageBox.Save | QMessageBox.Discard |
QMessageBox.Cancel)
if ret == QMessageBox.Save:
return self.OnSave()
elif ret == QMessageBox.Cancel:
if gMainWin.isEmbroidermodderMainWindowClosing:
gMainWin.isEmbroidermodderMainWindowClosing = False # Cancel closing the app.
return False
return True
def OnSave(self):
""""""
if self.filePath:
return self.OnSaveFilePath(self.filePath)
return self.OnSaveAs()
def OnSaveAs(self):
""""""
filePath, filtr = QFileDialog.getSaveFileName(self,
self.tr('Save As...'),
os.getcwd(),
WILDCARD_ALL)
if filePath:
return self.OnSaveFilePath(filePath)
return False
def OnSaveFilePath(self, filePath):
""""""
file = QFile(filePath)
if not file.open(QFile.WriteOnly | QFile.Text):
QMessageBox.warning(self, self.tr('Warning'),
self.tr('Cannot write file') + ' %s:\n%s.' % (filePath, file.errorString()))
return False
outf = QTextStream(file)
QApplication.setOverrideCursor(Qt.WaitCursor)
outf << self.toPlainText()
QApplication.restoreOverrideCursor()
self.DoSetCurrentFilePath(filePath)
# Clear the Modified Flag.
self.document().setModified(False)
self.setWindowModified(False)
self.setWindowTitle('%s[*]' % self.fileName)
return True
def OnPrint(self):
""""""
document = self.document()
printer = QPrinter()
dlg = QPrintDialog(printer, self)
if dlg.exec_() != QDialog.Accepted:
return
document.print_(printer)
def contextMenuEvent(self, event):
"""
Handles the ``contextMenuEvent`` event for :class:`MDISubWindow_TextEdit`.
:param `event`: a `QContextMenuEvent` event to be processed.
"""
menu = QMenu(self)
menu.addAction(self.action_Edit_Undo)
menu.addAction(self.action_Edit_Redo)
menu.addSeparator()
menu.addAction(self.action_Edit_Cut)
menu.addAction(self.action_Edit_Copy)
menu.addAction(self.action_Edit_Paste)
menu.addAction(self.action_Edit_Delete)
menu.addSeparator()
menu.addAction(self.action_Edit_SelectAll)
menu.popup(self.mapToGlobal(event.pos()))
# menu.exec_(self.mapToGlobal(event.pos()))
event.accept()
print("MDISubWindow_TextEdit contextMenuEvent")
def DoZoomOut(self):
""""""
self.zoomOut()
self.zoomLevel = self.zoomLevel - 1
def DoZoomIn(self):
""""""
self.zoomIn()
self.zoomLevel = self.zoomLevel + 1
def GetZoomLevel(self):
""""""
return self.zoomLevel
def DoZoomDefault(self):
""""""
if self.zoomLevel: # not == 0
if self.zoomLevel < 0:
while self.GetZoomLevel():
self.DoZoomIn()
else:
while self.GetZoomLevel():
self.DoZoomOut()
def OnDay(self):
""""""
self.setTextBackgroundColor(QColor('#FFFFFF'))
self.setTextColor(QColor('#000000'))
print('OnDay')
def OnNight(self):
""""""
self.setTextBackgroundColor(QColor('#000000'))
# self.setTextColor(QColor('#FFFFFF'))
# sample_palette = QPalette()
# sample_palette.setColor(QPalette.Window, Qt.white)
# sample_palette.setColor(QPalette.WindowText, Qt.blue)
# self.setAutoFillBackground(True)
# self.setPalette(sample_palette)
self.document().setDefaultStyleSheet("QTextEdit {color: white; background-color: black}")
# self.setStyleSheet("color: white; background-color: black")
# self.setStyleSheet("color: white;"
# "background-color: black;"
# "selection-color: black;"
# "selection-background-color: white;")
# self.setExtraSelections([(0, 1)])
# self.setAutoFillBackground(True)
# self.setBackgroundRole(QPalette.Background)
self.update()
print('OnNight')
def wheelEvent(self, event):
""""""
evtDelta = event.delta()
evtModifiers = event.modifiers()
evtAltDown = evtModifiers & Qt.AltModifier
evtShiftDown = evtModifiers & Qt.ShiftModifier
evtCtrlDown = evtModifiers & Qt.ControlModifier
## print('evtModifiers = %s' % evtModifiers)
## print('evtAltDown = %s' % evtAltDown)
## print('evtShiftDown = %s' % evtShiftDown)
## print('evtCtrlDown = %s' % evtCtrlDown)
## print('event.delta() = %s' % evtDelta)
# Ctrl+MouseWheel Zooming.
if (evtDelta < 0) and evtCtrlDown and not evtShiftDown and not evtAltDown:
if self.zoomLevel > -7:
self.DoZoomOut()
print('zoomLevel = %d' % self.zoomLevel)
elif (evtDelta > 0) and evtCtrlDown and not evtShiftDown and not evtAltDown:
if self.zoomLevel < 20:
self.DoZoomIn()
print('zoomLevel = %d' % self.zoomLevel)
# Shift+MouseWheel Horizontal Scrolling.
elif (evtDelta < 0) and not evtCtrlDown and evtShiftDown and not evtAltDown:
self.horizontalScrollBar().triggerAction(QAbstractSlider.SliderSingleStepAdd)
self.horizontalScrollBar().triggerAction(QAbstractSlider.SliderSingleStepAdd)
elif (evtDelta > 0) and not evtCtrlDown and evtShiftDown and not evtAltDown:
self.horizontalScrollBar().triggerAction(QAbstractSlider.SliderSingleStepSub)
self.horizontalScrollBar().triggerAction(QAbstractSlider.SliderSingleStepSub)
# Reproduce Regular Scrolling.
elif evtDelta < 0:
self.verticalScrollBar().triggerAction(QAbstractSlider.SliderSingleStepAdd)
self.verticalScrollBar().triggerAction(QAbstractSlider.SliderSingleStepAdd)
elif evtDelta > 0:
self.verticalScrollBar().triggerAction(QAbstractSlider.SliderSingleStepSub)
self.verticalScrollBar().triggerAction(QAbstractSlider.SliderSingleStepSub)
event.accept()
# event.ignore()
# numDegrees = event.delta() / 8
# numSteps = numDegrees / 15
# print('numDegrees = %s' % numDegrees)
# print('numSteps = %s' % numSteps)
#if event.orientation() == Qt.Horizontal:
# self.scroll(numSteps, 0)
# # self.scrollHorizontally(numSteps)
#else:
# self.scroll(0, numSteps)
# # self.scrollVertically(numSteps)
#event.accept()
def DoSetCurrentFilePath(self, filePath):
""""""
self.filePath = str(filePath)
self.fileName = os.path.basename(os.path.abspath(filePath))
self.fileExt = os.path.splitext(self.fileName)[1]
def closeEvent(self, event):
""""""
if self.AskToSaveBeforeClosing():
# self.DoWriteSettings()
event.accept()
else:
event.ignore()
def __init__(self, parent=None, filePath=''):
"""Default class constructor."""
super(MDISubWindow_TextEdit, self).__init__(parent)
print(filePath)
self.filePath = filePath
self.fileName = os.path.basename(os.path.abspath(filePath))
self.fileExt = os.path.splitext(self.fileName)[1]
if not filePath:
self.setWindowTitle('Untitled[*]')
parent.setWindowIcon(QIcon(gIconDir + os.sep + 'new.png'))
else:
f = open(filePath, 'r')
txt = f.read()
f.close()
self.setText(txt)
self.setWindowTitle('%s[*]' % self.fileName)
# TODO: This is changing all the subwindows icons. We want individual icons based on filetype...?
if self.fileExt in ('.py', '.pyw'):
parent.setWindowIcon(QIcon(gIconDir + os.sep + 'pyscript.png'))
else:
parent.setWindowIcon(QIcon(gIconDir + os.sep + 'new.png'))
monoFont = QFont('Courier New')
monoFont.setFixedPitch(True)
self.setFont(monoFont)
self.setWordWrapMode(QTextOption.NoWrap)
## self.setTextBackgroundColor(QColor('#000000'))
## self.setTextColor(QColor('#FFFFFF'))
self.setCursorWidth(2)
self.CreateActions()
self.zoomLevel = 0
gMainWin.action_Edit_Cut.setEnabled(False)
gMainWin.action_Edit_Copy.setEnabled(False)
self.copyAvailable.connect(gMainWin.action_Edit_Cut.setEnabled)
self.copyAvailable.connect(gMainWin.action_Edit_Copy.setEnabled)
# Handle the Context Menu Entries Also.
self.action_Edit_Undo.setEnabled(False)
self.action_Edit_Redo.setEnabled(False)
self.action_Edit_Cut.setEnabled(False)
self.action_Edit_Copy.setEnabled(False)
self.undoAvailable.connect(self.action_Edit_Undo.setEnabled)
self.redoAvailable.connect(self.action_Edit_Redo.setEnabled)
self.copyAvailable.connect(self.action_Edit_Cut.setEnabled)
self.copyAvailable.connect(self.action_Edit_Copy.setEnabled)
self.document().contentsChanged.connect(self.TheDocumentWasModified)
# self.show()
# self.showMaximized()
# self.setFocusPolicy(Qt.WheelFocus)
##### self.setFocus() # This makes the MDIArea go into SubWindowView...?
self.gCornerWidget = QToolButton(self)
# self.gCornerWidgetToolTip = QToolTip()
QToolTip.setFont(QFont('SansSerif', 10))
br = QBrush(QPixmap(gImgDir + os.sep + 'texture-spirals.png'))
pal = QPalette()
# pal.setBrush(QPalette.Active, QPalette.Base, br)
# pal.setColor(QPalette.Background, QColor('#FF8000'))
pal.setColor(QPalette.ColorGroup.Inactive,
QPalette.ColorRole.ToolTipBase,
QColor(EMBROIDERBLUE2))
QToolTip.setPalette(QPalette(pal))
self.action_Edit_SelectAll.setToolTip('This is a <b>QWidget</b> widget')
self.gCornerWidget.setDefaultAction(self.action_Edit_SelectAll)
self.setCornerWidget(self.gCornerWidget)
# We want to show the corner widget no matter what so...
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
class CustomCircuitCreator(QWidget):
def __init__(self):
super(CustomCircuitCreator, self).__init__()
self.PaintArea = PaintArea(self)
self.PaintArea.clearImage()
self.grid = QGridLayout(self)
self.grid.addWidget(self.PaintArea, 1, 0, 1, 9)
self.scrollArea = QScrollArea()
self.scrollArea.setBackgroundRole(QPalette.Dark)
self.createToolsButtons()
self.createButtons()
self.setWindowTitle("Custom circuit creator")
self.resize(self.PaintArea.size_w, self.PaintArea.size_h + 85)
def closeEvent(self, event):
if self.maybeSave():
event.accept()
else:
event.ignore()
def createButtons(self):
buttonsDialog = QDialogButtonBox(self)
buttonsDialog.setStandardButtons(
QDialogButtonBox.Save |
QDialogButtonBox.Cancel |
QDialogButtonBox.Reset)
self.grid.addWidget(buttonsDialog, 3, 0, 3, 9)
buttonsDialog.button(QDialogButtonBox.Save).clicked.connect(
self.saveFile)
buttonsDialog.button(QDialogButtonBox.Reset).clicked.connect(
self.PaintArea.clearImage)
buttonsDialog.button(QDialogButtonBox.Cancel).clicked.connect(
self.close)
def createToolsButtons(self):
buttonsFrame = QFrame()
buttonsLayout = QHBoxLayout(buttonsFrame)
buttonsLayout.setSizeConstraint(QLayout.SetDefaultConstraint)
iconPath = filePath('icons/')
self.penButton = QToolButton(
self,
icon=QIcon(iconPath + 'pen_w.png'))
self.penButton.setToolTip('freehand drawing')
self.penButton.clicked.connect(lambda: self.PaintArea.setTool('pen'))
buttonsLayout.addWidget(self.penButton)
self.lineButton = QToolButton(
self,
icon=QIcon(iconPath + 'line_w.png'))
self.lineButton.setToolTip('draw lines')
self.lineButton.clicked.connect(lambda: self.PaintArea.setTool('line'))
buttonsLayout.addWidget(self.lineButton)
self.rect = QToolButton(
self,
icon=QIcon(iconPath + 'rect_w.png'))
self.rect.setToolTip('create rectangle')
self.rect.clicked.connect(lambda: self.PaintArea.setTool('rect'))
buttonsLayout.addWidget(self.rect)
self.roundRect = QToolButton(
self,
icon=QIcon(iconPath + 'roundrect_w.png'))
self.roundRect.setToolTip('create a round-corner rectanlge')
self.roundRect.clicked.connect(
lambda: self.PaintArea.setTool('roundRect'))
buttonsLayout.addWidget(self.roundRect)
self.circle = QToolButton(
self,
icon=QIcon(iconPath + 'ellipse_w.png'))
self.circle.setToolTip('create circle')
self.circle.clicked.connect(lambda: self.PaintArea.setTool('circle'))
buttonsLayout.addWidget(self.circle)
self.eraser = QToolButton(
self,
icon=QIcon(iconPath + 'eraser_w.png'))
self.eraser.setToolTip('erase parts of the drawing')
self.eraser.clicked.connect(lambda: self.PaintArea.setTool('eraser'))
buttonsLayout.addWidget(self.eraser)
self.mirror_w = QToolButton(
self,
icon=QIcon(iconPath + 'mirror-w_w.png'))
self.mirror_w.setToolTip('vertical symmetric inversion')
self.mirror_w.clicked.connect(self.PaintArea.mirror_w)
buttonsLayout.addWidget(self.mirror_w)
self.mirror_h = QToolButton(
self,
icon=QIcon(iconPath + 'mirror-h_w.png'))
self.mirror_h.setToolTip('horizontal symmetric inversion')
self.mirror_h.clicked.connect(self.PaintArea.mirror_h)
buttonsLayout.addWidget(self.mirror_h)
self.rotate = QToolButton(
self,
icon=QIcon(iconPath + 'rotate_w.png'))
self.rotate.setToolTip('rotate')
self.rotate.clicked.connect(self.PaintArea.rotate)
buttonsLayout.addWidget(self.rotate)
self.grid.addWidget(buttonsFrame, 0, 0, QtCore.Qt.AlignLeft)
def maybeSave(self):
if self.PaintArea.isModified():
ret = QMessageBox.warning(
self, "Save your work",
"The drawing has been modified.\n"
"Do you want to save your changes ?",
QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)
if ret == QMessageBox.Save:
return self.saveFile('png')
elif ret == QMessageBox.Cancel:
return False
return True
def saveFile(self, fileFormat='png'):
initialPath = QtCore.QDir.currentPath() + '/customCirc.' + fileFormat
fileName = QFileDialog.getSaveFileName(
self, "Save As", initialPath, "%s Files (*.%s);;All Files (*)"
% (fileFormat.upper(), fileFormat))
if fileName:
if self.PaintArea.saveImage('customCirc.' + fileFormat):
self.close()
class MainWindow(QWidget, object):
master_password_label = None
master_password_edit = None
domain_label = None
domain_edit = None
username_label = None
username_edit = None
strength_label = None
strength_selector = None
password_label = None
password = None
sync_button = None
clipboard_button = None
setting = None
decrypt_kgk_task = None
settings_window = None
def __init__(self):
super(MainWindow, self).__init__()
self.nam = QNetworkAccessManager()
self.setWindowIcon(QIcon(os.path.join('icons', 'Logo_rendered_edited.png')))
layout = QBoxLayout(QBoxLayout.TopToBottom)
layout.setContentsMargins(0, 0, 0, 0)
self.preference_manager = PreferenceManager()
self.kgk_manager = KgkManager()
self.kgk_manager.set_preference_manager(self.preference_manager)
self.settings_manager = PasswordSettingsManager(self.preference_manager)
self.setting_dirty = True
# Header bar
header_bar = QFrame()
header_bar.setStyleSheet(
"QWidget { background: rgb(40, 40, 40); } " +
"QToolButton { background: rgb(40, 40, 40); }" +
"QToolTip { color: rgb(255, 255, 255); background-color: rgb(20, 20, 20); " +
"border: 1px solid white; }")
header_bar.setAutoFillBackground(True)
header_bar.setFixedHeight(45)
header_bar_layout = QBoxLayout(QBoxLayout.LeftToRight)
header_bar_layout.addStretch()
header_bar.setLayout(header_bar_layout)
layout.addWidget(header_bar)
self.create_header_bar(header_bar_layout)
# Widget area
main_area = QFrame()
main_layout = QBoxLayout(QBoxLayout.TopToBottom)
main_area.setLayout(main_layout)
layout.addWidget(main_area)
self.create_main_area(main_layout)
# Window layout
layout.addStretch()
main_layout.addStretch()
self.setLayout(layout)
settings = QSettings()
size = settings.value("MainWindow/size")
if not size:
size = QSize(350, 450)
self.resize(size)
position = settings.value("MainWindow/pos")
if not position:
position = QPoint(0, 24)
self.move(position)
self.setWindowTitle("c't SESAM")
self.master_password_edit.setFocus()
self.show()
# noinspection PyUnresolvedReferences
def create_header_bar(self, layout):
self.sync_button = QToolButton()
self.sync_button.setIconSize(QSize(30, 30))
self.sync_button.setIcon(QIcon(os.path.join("icons", "ic_action_sync.png")))
self.sync_button.setStyleSheet("border: 0px;")
self.sync_button.setToolTip("Sync")
self.sync_button.clicked.connect(self.sync_clicked)
self.sync_button.setVisible(False)
layout.addWidget(self.sync_button)
self.clipboard_button = QToolButton()
self.clipboard_button.setIconSize(QSize(30, 30))
self.clipboard_button.setIcon(QIcon(os.path.join("icons", "ic_action_copy.png")))
self.clipboard_button.setStyleSheet("border: 0px;")
self.clipboard_button.setToolTip("in die Zwischenablage")
self.clipboard_button.clicked.connect(self.copy_to_clipboard)
self.clipboard_button.setVisible(False)
layout.addWidget(self.clipboard_button)
# noinspection PyUnresolvedReferences
def create_main_area(self, layout):
# Master password
master_password_label = QLabel("&Master-Passwort:")
self.master_password_edit = QLineEdit()
self.master_password_edit.setEchoMode(QLineEdit.EchoMode.Password)
self.master_password_edit.textChanged.connect(self.masterpassword_changed)
self.master_password_edit.returnPressed.connect(self.move_focus)
self.master_password_edit.editingFinished.connect(self.masterpassword_entered)
self.master_password_edit.setMaximumHeight(28)
master_password_label.setBuddy(self.master_password_edit)
layout.addWidget(master_password_label)
layout.addWidget(self.master_password_edit)
# Domain
domain_label = QLabel("&Domain:")
self.domain_edit = QComboBox()
self.domain_edit.setEditable(True)
self.domain_edit.textChanged.connect(self.domain_changed)
self.domain_edit.currentIndexChanged.connect(self.domain_changed)
self.domain_edit.lineEdit().editingFinished.connect(self.domain_entered)
self.domain_edit.lineEdit().returnPressed.connect(self.move_focus)
self.domain_edit.setMaximumHeight(28)
domain_label.setBuddy(self.domain_edit)
layout.addWidget(domain_label)
layout.addWidget(self.domain_edit)
# Username
self.username_label = QLabel("&Username:"******"&Passwortstärke:")
self.strength_label.setVisible(False)
self.strength_selector = PasswordStrengthSelector()
self.strength_selector.set_min_length(4)
self.strength_selector.set_max_length(36)
self.strength_selector.setMinimumHeight(60)
self.strength_selector.set_length(12)
self.strength_selector.set_complexity(6)
self.strength_selector.strength_changed.connect(self.strength_changed)
self.strength_selector.setVisible(False)
self.strength_label.setBuddy(self.strength_selector)
layout.addWidget(self.strength_label)
layout.addWidget(self.strength_selector)
# Password
self.password_label = QLabel("&Passwort:")
self.password_label.setVisible(False)
self.password = QLabel()
self.password.setTextFormat(Qt.PlainText)
self.password.setAlignment(Qt.AlignCenter)
self.password.setFont(QFont("Helvetica", 18, QFont.Bold))
self.password.setVisible(False)
self.password_label.setBuddy(self.password)
layout.addWidget(self.password_label)
layout.addWidget(self.password)
def set_masterpassword(self, masterpassword):
self.master_password_edit.setText(masterpassword)
def set_domain(self, domain):
self.domain_edit.lineEdit().setText(domain)
def closeEvent(self, *args, **kwargs):
settings = QSettings()
settings.setValue("MainWindow/size", self.size())
settings.setValue("MainWindow/pos", self.pos())
settings.sync()
def masterpassword_changed(self):
self.kgk_manager.reset()
self.decrypt_kgk_task = None
self.clipboard_button.setVisible(False)
if len(self.master_password_edit.text()) > 0:
self.sync_button.setVisible(True)
else:
self.sync_button.setVisible(False)
def masterpassword_entered(self):
if len(self.master_password_edit.text()) > 0 and not self.decrypt_kgk_task:
self.kgk_manager.get_kgk_crypter_salt()
self.decrypt_kgk_task = DecryptKgkTask(
self.master_password_edit.text(),
self.preference_manager,
self.kgk_manager,
self.settings_manager,
self.domain_edit)
def set_visibilities(self):
if len(self.domain_edit.lineEdit().text()) > 0:
self.username_label.setVisible(True)
self.username_edit.setVisible(True)
self.strength_label.setVisible(True)
self.strength_selector.setVisible(True)
self.password_label.setVisible(True)
self.password.setVisible(True)
else:
self.username_label.setVisible(False)
self.username_edit.setVisible(False)
self.strength_label.setVisible(False)
self.strength_selector.setVisible(False)
self.password_label.setVisible(False)
self.password.setVisible(False)
self.clipboard_button.setVisible(False)
def domain_changed(self):
self.setting_dirty = True
self.password.setText("")
self.clipboard_button.setVisible(False)
self.set_visibilities()
if self.kgk_manager.has_kgk() and (not self.decrypt_kgk_task or not self.decrypt_kgk_task.is_running()) and \
len(self.domain_edit.lineEdit().text()) > 0 and \
self.domain_edit.lineEdit().text() in self.settings_manager.get_domain_list():
self.domain_entered()
def domain_entered(self):
self.setting_dirty = self.domain_edit.lineEdit().text() not in self.settings_manager.get_domain_list()
self.setting = self.settings_manager.get_setting(self.domain_edit.lineEdit().text())
self.username_edit.blockSignals(True)
self.username_edit.setText(self.setting.get_username())
self.username_edit.blockSignals(False)
self.strength_selector.blockSignals(True)
self.strength_selector.set_length(self.setting.get_length())
self.strength_selector.set_complexity(self.setting.get_complexity())
self.strength_selector.set_extra_count(len(self.setting.get_extra_character_set()))
self.strength_selector.blockSignals(False)
self.generate_password()
def move_focus(self):
line_edits = [self.master_password_edit, self.domain_edit, self.username_edit]
for i, edit in enumerate(line_edits):
if edit.hasFocus() and i + 1 < len(line_edits):
line_edits[i + 1].setFocus()
return True
self.generate_button.setFocus()
def generate_password(self):
if not self.kgk_manager.has_kgk():
self.kgk_manager.create_new_kgk()
self.kgk_manager.create_and_save_new_kgk_block()
if not self.kgk_manager.kgk_crypter or not self.kgk_manager.salt:
self.kgk_manager.get_kgk_crypter(self.master_password_edit.text().encode('utf-8'),
self.kgk_manager.get_kgk_crypter_salt())
if self.setting_dirty:
self.setting.new_salt()
self.setting.calculate_template()
self.settings_manager.set_setting(self.setting)
if not self.setting.get_legacy_password():
generator = CtSesam(self.setting.get_domain(),
self.setting.get_username(),
self.kgk_manager.get_kgk(),
self.setting.get_salt(),
self.setting.get_iterations())
password = generator.generate(self.setting)
else:
password = self.setting.get_legacy_password()
self.password.setText(password)
self.password.setTextInteractionFlags(Qt.TextSelectableByMouse | Qt.TextSelectableByKeyboard)
self.clipboard_button.setVisible(True)
self.settings_manager.store_local_settings(self.kgk_manager)
self.setting_dirty = False
def copy_to_clipboard(self):
QApplication.clipboard().setText(self.password.text())
def username_changed(self):
if self.setting:
if self.setting.get_username() != self.username_edit.text():
self.setting.set_username(self.username_edit.text())
self.setting_dirty = True
self.generate_password()
def strength_changed(self, complexity, length):
if self.setting:
if self.setting.get_length() != length:
self.setting.set_length(length)
self.setting_dirty = True
if self.setting.get_complexity() != complexity:
self.setting.set_complexity(complexity)
self.setting_dirty = True
self.generate_password()
def migrate_local_domains(self, new_kgk_manager):
for domain in self.settings_manager.get_domain_list():
setting = self.settings_manager.get_setting(domain)
generator = CtSesam(setting.get_domain(),
setting.get_username(),
self.kgk_manager.get_kgk(),
setting.get_salt(),
setting.get_iterations())
setting.set_legacy_password(generator.generate(setting))
self.settings_manager.set_setting(setting)
self.kgk_manager = new_kgk_manager
self.settings_manager.store_local_settings(self.kgk_manager)
# noinspection PyUnresolvedReferences
def sync_clicked(self):
self.masterpassword_entered()
if not self.settings_manager.sync_manager.has_settings():
self.show_sync_settings()
else:
pull_successful, data = self.settings_manager.sync_manager.pull()
if pull_successful and len(data) > 0:
remote_kgk_manager = KgkManager()
remote_kgk_manager.update_from_blob(self.master_password_edit.text().encode('utf-8'), b64decode(data))
if len(self.preference_manager.get_kgk_block()) == 112 and \
remote_kgk_manager.has_kgk() and self.kgk_manager.has_kgk() and \
self.kgk_manager.get_kgk() != remote_kgk_manager.get_kgk():
if len(self.settings_manager.get_domain_list()) > 0:
print("Lokal und auf dem Server gibt es unterschiedliche KGKs. Das ist ein Problem!")
self.migrate_local_domains(remote_kgk_manager)
else:
if len(self.preference_manager.get_kgk_block()) != 112:
self.kgk_manager = remote_kgk_manager
self.kgk_manager.set_preference_manager(self.preference_manager)
self.kgk_manager.store_local_kgk_block()
self.settings_manager.update_from_export_data(remote_kgk_manager, b64decode(data))
self.domain_edit.blockSignals(True)
current_domain = self.domain_edit.lineEdit().text()
for i in reversed(range(self.domain_edit.count())):
self.domain_edit.removeItem(i)
self.domain_edit.insertItems(0, self.settings_manager.get_domain_list())
self.domain_edit.blockSignals(False)
self.domain_edit.setEditText(current_domain)
self.settings_manager.store_settings(self.kgk_manager)
# noinspection PyUnresolvedReferences
def show_sync_settings(self, url=None, username=None, password=None):
self.settings_window = SettingsWindow(
self.settings_manager.sync_manager,
self.nam,
url=self.settings_manager.sync_manager.server_address,
username=self.settings_manager.sync_manager.username,
password=self.settings_manager.sync_manager.password,
certificate=self.settings_manager.sync_manager.certificate)
self.settings_window.finished.connect(self.sync_clicked)
class SearchEdit(QLineEdit):
'''
SearchEdit
Styled search edit box which includes a search icon, clear button, and
pre-defined preview text.
'''
def __init__(self, parent=None):
super(SearchEdit, self).__init__(parent)
clr_pixmap = QPixmap(':/icons/clear.png')
self._btn_clear = QToolButton(self)
self._btn_clear.setIcon(clr_pixmap)
self._btn_clear.setIconSize(clr_pixmap.size())
self._btn_clear.setCursor(Qt.ArrowCursor)
self._btn_clear.setStyleSheet('QToolButton { border: none; padding: 0px; }');
self._btn_clear.clicked.connect(self.clear)
fw = self.style().pixelMetric(QStyle.PM_DefaultFrameWidth)
#TODO: Make a Search glyph show up properly
self.setStyleSheet('QLineEdit { padding-right: %dpx; }' % (self._btn_clear.sizeHint().width() + fw + 1))
msz = self.minimumSizeHint()
self.setMinimumSize(max([msz.width(), self._btn_clear.sizeHint().height() + fw * 2 + 2]),
max([msz.height(), self._btn_clear.sizeHint().height() + fw * 2 + 2]))
self.setPlaceholderText('Search')
def resizeEvent(self, e):
sz = self._btn_clear.sizeHint()
fw = self.style().pixelMetric(QStyle.PM_DefaultFrameWidth)
self._btn_clear.move(self.rect().right() - fw - sz.width(),
(self.rect().bottom() + 1 - sz.height()) / 2 + 1)
def sizeHint(self):
s = super(SearchEdit, self).sizeHint()
s.setWidth(250)
return s
def __init__(self, parent=None):
"""Initialize the parent class of this instance."""
super(window, self).__init__(parent)
app.aboutToQuit.connect(self.myExitHandler)
self.style_sheet = self.styleSheet('style')
# app.setStyle(QStyleFactory.create('Macintosh'))
#app.setStyleSheet(self.style_sheet)
self.layout().setSpacing(0)
self.layout().setContentsMargins(0,0,0,0)
app.setOrganizationName("Eivind Arvesen")
app.setOrganizationDomain("https://github.com/eivind88/raskolnikov")
app.setApplicationName("Raskolnikov")
app.setApplicationVersion("0.0.1")
settings = QSettings()
self.data_location = QDesktopServices.DataLocation
self.temp_location = QDesktopServices.TempLocation
self.cache_location = QDesktopServices.CacheLocation
self.startpage = "https://duckduckgo.com/"
self.new_tab_behavior = "insert"
global bookmarks
global saved_tabs
print "Currently saved_tabs:\n", saved_tabs
global menubar
menubar = QMenuBar()
# Initialize a statusbar for the window
self.statusbar = self.statusBar()
self.statusbar.setFont(QFont("Helvetica Neue", 11, QFont.Normal))
self.statusbar.setStyleSheet(self.style_sheet)
self.statusbar.setMinimumHeight(15)
self.pbar = QProgressBar()
self.pbar.setMaximumWidth(100)
self.statusbar.addPermanentWidget(self.pbar)
self.statusbar.hide()
self.setMinimumSize(504, 235)
# self.setWindowModified(True)
# app.alert(self, 0)
self.setWindowTitle("Raskolnikov")
# toolbar = self.addToolBar('Toolbar')
# toolbar.addAction(exitAction)
# self.setUnifiedTitleAndToolBarOnMac(True)
self.setWindowIcon(QIcon(""))
# Create input widgets
self.bbutton = QPushButton(u"<")
self.fbutton = QPushButton(u">")
self.hbutton = QPushButton(u"⌂")
self.edit = QLineEdit("")
self.edit.setFont(QFont("Helvetica Neue", 12, QFont.Normal))
self.edit.setPlaceholderText("Enter URL")
# self.edit.setMinimumSize(400, 24)
self.rbutton = QPushButton(u"↻")
self.dbutton = QPushButton(u"☆")
self.tbutton = QPushButton(u"⁐")
# ↆ ⇧ √ ⌘ ⏎ ⏏ ⚠ ✓ ✕ ✖ ✗ ✘ ::: ❤ ☮ ☢ ☠ ✔ ☑ ♥ ✉ ☣ ☤ ✘ ☒ ♡ ツ ☼ ☁ ❅ ✎
self.nbutton = QPushButton(u"+")
self.nbutton.setObjectName("NewTab")
self.nbutton.setMinimumSize(35, 30)
self.nbutton.setSizePolicy(QSizePolicy.Minimum,QSizePolicy.Minimum)
self.edit.setTextMargins(2, 1, 2, 0)
# create a horizontal layout for the input
input_layout = QHBoxLayout()
input_layout.setSpacing(4)
input_layout.setContentsMargins(0, 0, 0, 0)
# add the input widgets to the input layout
input_layout.addWidget(self.bbutton)
input_layout.addWidget(self.fbutton)
input_layout.addWidget(self.hbutton)
input_layout.addWidget(self.edit)
input_layout.addWidget(self.rbutton)
input_layout.addWidget(self.dbutton)
input_layout.addWidget(self.tbutton)
# create a widget to hold the input layout
self.input_widget = QFrame()
self.input_widget.setObjectName("InputWidget")
self.input_widget.setStyleSheet(self.style_sheet)
# set the layout of the widget
self.input_widget.setLayout(input_layout)
self.input_widget.setVisible(True)
# CREATE BOOKMARK-LINE HERE
self.bookmarks_layout = QHBoxLayout()
self.bookmarks_layout.setSpacing(0)
self.bookmarks_layout.setContentsMargins(0, 0, 0, 0)
for i in bookmarks:
link = QToolButton()
link.setDefaultAction(QAction(unicode(i), link))
link.setObjectName(unicode(i))
link.setFont(QFont("Helvetica Neue", 11, QFont.Normal))
link.clicked.connect(self.handleBookmarks)
self.bookmarks_layout.addWidget(link)
self.bookmarks_widget = QFrame()
self.bookmarks_widget.setObjectName("BookmarkWidget")
self.bookmarks_widget.setStyleSheet(self.style_sheet)
self.bookmarks_widget.setLayout(self.bookmarks_layout)
if not bookmarks:
self.bookmarks_widget.hide()
# Task list
self.tasklist = QStandardItemModel()
#parentItem = self.tasklist.invisibleRootItem()
#self.tasklist.header().hide()
self.tasklist.setHorizontalHeaderItem(0, QStandardItem('Tasks'))
parentItem = QStandardItem("Parent")
self.tasklist.appendRow(parentItem)
for i in range(4):
item = QStandardItem("Item %d" % i)
parentItem.appendRow(item)
#parentItem = item
#self.list.activated[str].connect(self.handleBookmarks)
#self.list.view().setSizePolicy(QSizePolicy.Minimum,QSizePolicy.Minimum)
# create tabs
self.tabs = QTabWidget()
self.tabs.setDocumentMode(True)
self.tabs.setTabsClosable(True)
self.tabs.setMovable(True)
self.tabs.tabBar().hide()
self.tabs.setFont(QFont("Helvetica Neue", 11, QFont.Normal))
self.tabs.setCornerWidget(self.nbutton)
self.tabs.cornerWidget().setObjectName("CornerWidget")
self.tabs.cornerWidget().setMinimumSize(10, 24)
self.tabs.cornerWidget().setSizePolicy(QSizePolicy.Minimum,QSizePolicy.Minimum)
if saved_tabs:
for tab in saved_tabs['tabs']:
tasklist = QTreeView()
tasklist.hide()
tasklist.setObjectName('taskList')
tasklist.setMinimumWidth(100)
tasklist.setMaximumWidth(250)
new_tab = QWebView()
new_tab.setObjectName('webView')
inspector = QWebInspector(self)
inspector.setObjectName('webInspector')
inspector.hide()
page_layout = QVBoxLayout()
page_layout.setSpacing(0)
page_layout.setContentsMargins(0, 0, 0, 0)
page_layout.addWidget(new_tab)
page_layout.addWidget(inspector)
page_widget = QFrame()
page_widget.setObjectName('pageWidget')
page_widget.setLayout(page_layout)
complete_tab_layout = QHBoxLayout()
complete_tab_layout.setSpacing(0)
complete_tab_layout.setContentsMargins(0, 0, 0, 0)
complete_tab_layout.addWidget(tasklist)
complete_tab_layout.addWidget(page_widget)
complete_tab_widget = QFrame()
complete_tab_widget.setLayout(complete_tab_layout)
#for page in tab['history']:
# new_tab.load(QUrl(page['url']))
#print tab['current_history']
#for item in new_tab.history().items():
# print item
#new_tab.history().goToItem(new_tab.history().itemAt(tab['current_history']))
new_tab.load(QUrl(tab['history'][tab['current_history']]['url']))
tab['current_history']
self.tabs.setUpdatesEnabled(False)
if self.new_tab_behavior == "insert":
self.tabs.insertTab(self.tabs.currentIndex()+1, complete_tab_widget,
unicode(new_tab.title()))
elif self.new_tab_behavior == "append":
self.tabs.appendTab(complete_tab_widget, unicode(new_tab.title()))
self.tabs.setUpdatesEnabled(True)
new_tab.titleChanged.connect(self.change_tab)
new_tab.urlChanged.connect(self.change_tab)
new_tab.loadStarted.connect(self.load_start)
new_tab.loadFinished.connect(self.load_finish)
new_tab.loadProgress.connect(self.pbar.setValue)
new_tab.page().linkHovered.connect(self.linkHover)
inspector.setPage(new_tab.page())
for index, tab in enumerate(saved_tabs['tabs']):
self.tabs.setTabText(index, tab['history'][tab['current_history']]['title'])
self.tabs.setCurrentIndex(saved_tabs['current_tab'])
else:
self.new_tab()
tabs_layout = QVBoxLayout()
tabs_layout.setSpacing(0)
tabs_layout.setContentsMargins(0, 0, 0, 0)
tabs_layout.addWidget(self.tabs)
self.tabs_widget = QFrame()
self.tabs_widget.setObjectName("TabLine")
self.tabs_widget.setStyleSheet(self.style_sheet)
self.tabs_widget.setLayout(tabs_layout)
self.tabs_widget.setVisible(True)
# Webkit settings
gsettings = self.tabs.currentWidget().findChild(QFrame, unicode('pageWidget')).findChild(QWebView, unicode('webView')).settings().globalSettings()
# Basic settings
gsettings.setAttribute(QWebSettings.AutoLoadImages, True)
gsettings.setAttribute(QWebSettings.JavascriptEnabled, True)
gsettings.setAttribute(QWebSettings.JavascriptCanOpenWindows, False)
gsettings.setAttribute(QWebSettings.JavascriptCanAccessClipboard, False)
gsettings.setAttribute(QWebSettings.PluginsEnabled, False) # Flash isn't stable at present
gsettings.setAttribute(QWebSettings.JavaEnabled, False) # Java applet's aren't supported by PySide
gsettings.setAttribute(QWebSettings.DeveloperExtrasEnabled, True)
gsettings.setAttribute(QWebSettings.AcceleratedCompositingEnabled,
True)
# Performace settings
gsettings.setAttribute(QWebSettings.DnsPrefetchEnabled, True)
gsettings.setAttribute(QWebSettings.AcceleratedCompositingEnabled, True)
gsettings.setAttribute(QWebSettings.DnsPrefetchEnabled, True)
# Other settings
gsettings.setAttribute(QWebSettings.PrivateBrowsingEnabled, False)
# Create a vertical layout and add widgets
vlayout = QVBoxLayout()
vlayout.setSpacing(0)
vlayout.setContentsMargins(0, 0, 0, 0)
# toolbar.addWidget(self.input_widget)
vlayout.addWidget(self.input_widget)
vlayout.addWidget(self.bookmarks_widget)
vlayout.addWidget(self.tabs_widget)
# create a widget to hold the vertical layout
wrapper_widget = QWidget()
wrapper_widget.setLayout(vlayout)
self.setCentralWidget(wrapper_widget)
self.bbutton.clicked.connect(self.tabs.currentWidget().findChild(QFrame, unicode('pageWidget')).findChild(QWebView, unicode('webView')).back)
self.fbutton.clicked.connect(self.tabs.currentWidget().findChild(QFrame, unicode('pageWidget')).findChild(QWebView, unicode('webView')).forward)
self.hbutton.clicked.connect(self.goHome)
self.edit.returnPressed.connect(self.set_url)
# Add button signal to "go" slot
self.rbutton.clicked.connect(self.tabs.currentWidget().findChild(QFrame, unicode('pageWidget')).findChild(QWebView, unicode('webView')).reload)
self.dbutton.clicked.connect(self.bookmark)
self.tbutton.clicked.connect(self.toggleTaskBar)
self.nbutton.clicked.connect(self.new_tab)
self.tabs.tabCloseRequested.connect(self.tabs.removeTab)
self.tabs.currentChanged.connect(self.change_tab)
widgets = (input_layout.itemAt(i).widget() for i in range(
input_layout.count()))
for widget in widgets:
if isinstance(widget, QPushButton):
widget.setFixedSize(33, 21)
widget.setFont(QFont("Helvetica Neue", 12, QFont.Normal))
widget.pressed.connect(self.press_button)
widget.released.connect(self.release_button)
# make a ctrl+q quit
sequence = QKeySequence(Qt.CTRL + Qt.Key_Q)
QShortcut(sequence, self, SLOT("close()"))
# make an accelerator to toggle fullscreen
sequence = QKeySequence(Qt.CTRL + Qt.SHIFT + Qt.Key_F)
QShortcut(sequence, self, self.toggle_fullscreen)
# make an accelerator to toggle input visibility
sequence = QKeySequence(Qt.CTRL + Qt.ALT + Qt.Key_L)
QShortcut(sequence, self, self.toggle_input)
# make an accelerator to focus adress-bar
sequence = QKeySequence(Qt.CTRL + Qt.Key_L)
QShortcut(sequence, self, self.focus_adress)
# make an accelerator to reload page
sequence = QKeySequence(Qt.CTRL + Qt.Key_R)
QShortcut(sequence, self, self.tabs.currentWidget().findChild(QFrame, unicode('pageWidget')).findChild(QWebView, unicode('webView')).reload)
# make an accelerator to create new tab
sequence = QKeySequence(Qt.CTRL + Qt.Key_T)
QShortcut(sequence, self, self.new_tab)
# make an accelerator to close tab
sequence = QKeySequence(Qt.CTRL + Qt.Key_W)
QShortcut(sequence, self, self.close_tab)
# make an accelerator to navigate tabs
sequence = QKeySequence(Qt.CTRL + Qt.SHIFT + Qt.Key_Left)
QShortcut(sequence, self, self.previous_tab)
sequence = QKeySequence(Qt.CTRL + Qt.SHIFT + Qt.Key_Right)
QShortcut(sequence, self, self.next_tab)
# make an accelerator to toggle inspector
sequence = QKeySequence(Qt.CTRL + Qt.ALT + Qt.Key_U)
QShortcut(sequence, self, self.handleShowInspector)
# make an accelerator to toggle bookmark
sequence = QKeySequence(Qt.CTRL + Qt.Key_D)
QShortcut(sequence, self, self.bookmark)
# make an accelerator to toggle task/project-list
sequence = QKeySequence(Qt.CTRL + Qt.SHIFT + Qt.Key_L)
QShortcut(sequence, self, self.toggleTaskBar)
# finally set the attribute need to rotate
# try:
# self.setAttribute(Qt.WA_Maemo5AutoOrientation, True)
# except:
# print "not maemo"
self.statusbar.show()
def _init_toolbar(self):
self.basedir = os.path.join(matplotlib.rcParams['datapath'], 'images')
layout = QVBoxLayout(self)
#a = QToolButton(self._icon('home.png'), u'原状', self.home)
a = QToolButton(self)
layout.addWidget(a)
a.setToolTip(u'恢复初始状态')
#a = QToolButton(self._icon('back.png'), u'后退', self.back)
a = QToolButton(self)
layout.addWidget(a)
a.setToolTip(u'前一个视图')
#a = QToolButton(self._icon('forward.png'), u'前进', self.forward)
a = QToolButton(self)
layout.addWidget(a)
a.setToolTip(u'下一个视图')
#a = QToolButton(self._icon('move.png'), u'平移', self.pan)
a = QToolButton(self)
layout.addWidget(a)
a.setToolTip('Pan axes with left mouse, zoom with right')
#a = QToolButton(self._icon('zoom_to_rect.png'), 'Zoom', self.zoom)
a = QToolButton(self)
layout.addWidget(a)
a.setToolTip('Zoom to rectangle')
class MainWindow(QMainWindow):
"""docstring for MainWindow"""
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.serviceProvider = 0
self.popupMenu = None
self.mapControlButtons = []
self.mapControlTypes = []
self.markerObjects = []
self.setWindowTitle(self.tr('Map Viewer Demo'))
self.routingManager = None
self.mapManager = None
self.mapWidget = None
self.markerIcon = None
self.slider = None
manager = QNetworkConfigurationManager()
canStartIAP = manager.capabilities() & QNetworkConfigurationManager.CanStartAndStopInterfaces
configuration = manager.defaultConfiguration()
if not configuration.isValid or (not canStartIAP and configuration.starte() != QNetworkConfiguration.Active):
QMessageBox.information(self, self.tr('Map Viewer Demo'),
self.tr('Available Access Points not found.'))
return
self.session = QNetworkSession(configuration, self)
self.session.opened.connect(self.networkSessionOpened)
self.session.error.connect(self.error)
self.session.open()
self.session.waitForOpened()
self.setProvider('nokia')
self.setupUi()
def networkSessionOpened(self):
pass
def sliderValueChanged(self, value):
self.mapWidget.setZoomLevel(value)
def mapZoomLevelChanged(self, level):
self.slider.setSliderPosition(int(level))
def mapTypeChanged(self, newType):
index = self.mapControlTypes.index(newType)
if index != -1:
self.mapControButtons[index].setChecked(True)
def mapTypeToggled(self, checked):
if checked:
button = self.sender()
index = self.mapControlButtons.index(button)
if index != -1:
print index, self.mapControlTypes[index]
self.mapWidget.setMapType(self.mapControlTypes[index])
def updateCoords(self, coords):
if not coords.isValid():
return
self.latitudeEdit.setText('%f' % coords.latitude())
self.longitudeEdit.setText('%f' % coords.longitude())
def setCoordsClicked(self):
lat = float(self.latitudeEdit.text())
lon = float(self.longitudeEdit.text())
self.mapWidget.setCenter(QGeoCoordinate(lat, lon))
def setProvider(self, providerId):
self.serviceProvider = QGeoServiceProvider(providerId)
if self.serviceProvider.error() != QGeoServiceProvider.NoError:
QMessageBox.information(self, self.tr('MapViewer Example'),
self.tr('Unable to dinf the %s geoservices plugin.' % providerId))
qApp.quit()
return
self.mapManager = self.serviceProvider.mappingManager()
self.routingManager = self.serviceProvider.routingManager()
def error(self, error):
if error == QNetworkSession.UnknownSessionError:
msgBox = QMessageBox(self.parent())
msgBox.setText('This application requires network access to function.')
msgBox.setInformativeText('Press Cancel to quit the application.')
msgBox.setStandardButtons(QMessageBox.Retry | QMessageBox.Cancel)
msgBox.setIcon(QMessageBox.Information)
msgBox.setDefaultButton(QMessageBox.Retry)
ret = msgBox.exec_()
if ret == QMessageBox.Retry:
QTimer.singleShot(0, self.session.open)
elif ret == QMessageBox.Cancel:
self.close()
elif error == QNetworkSession.SessionAbortedError:
msgBox = QMessageBox(self.parent())
msgBox.setText('Out of range of network')
msgBox.setInformativeText('Move back into range and press Retry, or press Cancel to quit the application')
msgBox.setStandardButtons(QMessageBox.Retry | QMessageBox.Cancel)
msgBox.setIcon(QMessageBox.Information)
msgBox.setDefaultButton(QMessageBox.Retry)
ret = msgBox.exec_()
if ret == QMessageBox.Retry:
QTimer.singleShot(0, self.session.open)
elif ret == QMessageBox.Cancel:
self.close()
def setupUi(self):
scene = QGraphicsScene(self)
self.view = QGraphicsView(scene, self)
self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setVisible(True)
self.view.setInteractive(True)
self.createPixmapIcon()
self.mapWidget = MapWidget(self.mapManager)
scene.addItem(self.mapWidget)
self.mapWidget.setCenter(QGeoCoordinate(-8.1, -34.95))
self.mapWidget.setZoomLevel(5)
#...
self.slider = QSlider(Qt.Vertical, self)
self.slider.setTickInterval(1)
self.slider.setTickPosition(QSlider.TicksBothSides)
self.slider.setMaximum(self.mapManager.maximumZoomLevel())
self.slider.setMinimum(self.mapManager.minimumZoomLevel())
self.slider.valueChanged[int].connect(self.sliderValueChanged)
self.mapWidget.zoomLevelChanged[float].connect(self.mapZoomLevelChanged)
mapControlLayout = QVBoxLayout()
self.mapWidget.mapTypeChanged.connect(self.mapTypeChanged)
for mapType in self.mapWidget.supportedMapTypes():
radio = QRadioButton(self)
if mapType == QGraphicsGeoMap.StreetMap:
radio.setText('Street')
elif mapType == QGraphicsGeoMap.SatelliteMapDay:
radio.setText('Sattelite')
elif mapType == QGraphicsGeoMap.SatelliteMapNight:
radio.setText('Sattelite - Night')
elif mapType == QGraphicsGeoMap.TerrainMap:
radio.setText('Terrain')
if mapType == self.mapWidget.mapType():
radio.setChecked(True)
radio.toggled[bool].connect(self.mapTypeToggled)
self.mapControlButtons.append(radio)
self.mapControlTypes.append(mapType)
mapControlLayout.addWidget(radio)
self.latitudeEdit = QLineEdit()
self.longitudeEdit = QLineEdit()
formLayout = QFormLayout()
formLayout.addRow('Latitude', self.latitudeEdit)
formLayout.addRow('Longitude', self.longitudeEdit)
self.captureCoordsButton = QToolButton()
self.captureCoordsButton.setText('Capture coordinates')
self.captureCoordsButton.setCheckable(True)
self.captureCoordsButton.toggled[bool].connect(
self.mapWidget.setMouseClickCoordQuery)
self.mapWidget.coordQueryResult.connect(self.updateCoords)
self.setCoordsButton = QPushButton()
self.setCoordsButton.setText('Set coordinates')
self.setCoordsButton.clicked.connect(self.setCoordsClicked)
buttonLayout = QHBoxLayout()
buttonLayout.addWidget(self.captureCoordsButton)
buttonLayout.addWidget(self.setCoordsButton)
coordControlLayout = QVBoxLayout()
coordControlLayout.addLayout(formLayout)
coordControlLayout.addLayout(buttonLayout)
widget = QWidget(self)
layout = QGridLayout()
layout.setRowStretch(0, 1)
layout.setRowStretch(1, 0)
topLayout = QGridLayout()
bottomLayout = QGridLayout()
topLayout.setColumnStretch(0, 0)
topLayout.setColumnStretch(1, 1)
bottomLayout.setColumnStretch(0, 0)
bottomLayout.setColumnStretch(1, 1)
topLayout.addWidget(self.slider, 0, 0)
topLayout.addWidget(self.view, 0, 1)
bottomLayout.addLayout(mapControlLayout, 0, 0)
bottomLayout.addLayout(coordControlLayout, 0, 1)
layout.addLayout(topLayout, 0, 0)
layout.addLayout(bottomLayout, 1, 0)
self.layout = layout
widget.setLayout(layout)
self.setCentralWidget(widget)
self.view.setContextMenuPolicy(Qt.CustomContextMenu)
self.view.customContextMenuRequested.connect(self.customContextMenuRequest)
def createPixmapIcon(self):
self.markerIcon = QPixmap(MARKER_WIDTH, MARKER_HEIGHT)
self.markerIcon.fill(Qt.transparent)
painter = QPainter(self.markerIcon)
p1 = QPoint(MARKER_WIDTH / 2, MARKER_HEIGHT - 1)
p2 = QPoint(MARKER_WIDTH / 2, MARKER_HEIGHT - 1 - MARKER_PIN_LEN)
pen = QPen(Qt.black)
pen.setWidth(2)
pen.setCosmetic(True)
painter.setPen(pen)
painter.drawLine(p1, p2)
ellipse = QRect(0, 0, MARKER_WIDTH - 1, MARKER_HEIGHT - 1)
pen.setWidth(1)
painter.setPen(pen)
color = QColor(Qt.green)
color.setAlpha(127)
brush = QBrush(color)
painter.setBrush(brush)
painter.drawEllipse(ellipse)
def resizeEvent(self, event):
self.view.setSceneRect(QRectF(QPointF(0.0, 0.0), self.view.size()))
self.mapWidget.resize(self.view.size())
def showEvent(self, event):
self.view.setSceneRect(QRectF(QPointF(0.0, 0.0), self.view.size()))
self.mapWidget.resize(self.view.size())
def createMenus(self):
self.popupMenu = QMenu(self)
# Markers
subMenuItem = QMenu(self.tr('Marker'), self)
self.popupMenu.addMenu(subMenuItem)
menuItem = QAction(self.tr('Set marker'), self)
subMenuItem.addAction(menuItem)
menuItem.triggered[bool].connect(self.drawPixmap)
menuItem = QAction(self.tr('Remove marker'), self)
subMenuItem.addAction(menuItem)
menuItem.triggered[bool].connect(self.removePixmaps)
menuItem = QAction(self.tr('Select objects'), self)
subMenuItem.addAction(menuItem)
menuItem.triggered[bool].connect(self.selectObjects)
# Draw
subMenuItem = QMenu(self.tr('Draw'), self)
self.popupMenu.addMenu(subMenuItem)
menuItem = QAction(self.tr('Rectangle'), self)
subMenuItem.addAction(menuItem)
menuItem.triggered[bool].connect(self.drawRect)
menuItem = QAction(self.tr('Polyline'), self)
subMenuItem.addAction(menuItem)
menuItem.triggered[bool].connect(self.drawPolyline)
menuItem = QAction(self.tr('Polygon'), self)
subMenuItem.addAction(menuItem)
menuItem.triggered[bool].connect(self.drawPolygon)
menuItem = QAction(self.tr('Circle'), self)
subMenuItem.addAction(menuItem)
menuItem.triggered[bool].connect(self.drawCircle)
menuItem = QAction(self.tr('Text'), self)
subMenuItem.addAction(menuItem)
menuItem.triggered[bool].connect(self.drawText)
# Routing
subMenuItem = QMenu(self.tr('Route'), self)
self.popupMenu.addMenu(subMenuItem)
menuItem = QAction(self.tr('Calculate route'), self)
subMenuItem.addAction(menuItem)
menuItem.triggered[bool].connect(self.calculateRoute)
def selectObjects(self):
for obj in self.mapWidget.mapObjects():
obj.setSelected(False)
if len(self.markerObjects) < 2:
return
bottomRight = self.markerObjects.pop()
topLeft = self.markerObjects.pop()
self.mapWidget.removeMapObject(topLeft)
self.mapWidget.removeMapObject(bottomRight)
selectedObjects = self.mapWidget.mapObjectsInScreenRect(
QRectF(self.mapWidget.coordinateToScreenPosition(topLeft.coordinate()),
self.mapWidget.coordinateToScreenPosition(bottomRight.coordinate()))
)
for obj in selectedObjects:
obj.setSelected(True)
def drawRect(self):
if len(self.markerObjects) < 2:
return
p1, p2 = self.markerObjects[:2]
pen = QPen(Qt.white)
pen.setWidth(2)
pen.setCosmetic(True)
fill = QColor(Qt.black)
fill.setAlpha(65)
rectangle = QGeoMapRectangleObject(p1.coordinate(), p2.coordinate())
rectangle.setPen(pen)
rectangle.setBrush(QBrush(fill))
self.mapWidget.addMapObject(rectangle)
def drawPolyline(self):
path = [mark.coordinate() for mark in self.markerObjects]
pen = QPen(Qt.white)
pen.setWidth(2)
pen.setCosmetic(True)
polyline = QGeoMapPolylineObject()
polyline.setPen(pen)
polyline.setPath(path)
self.mapWidget.addMapObject(polyline)
def drawPolygon(self):
path = [mark.coordinate() for mark in self.markerObjects]
pen = QPen(Qt.white)
pen.setWidth(2)
pen.setCosmetic(True)
polygon = QGeoMapPolygonObject()
polygon.setPen(pen)
fill = QColor(Qt.black)
fill.setAlpha(65)
polygon.setBrush(QBrush(fill))
polygon.setPath(path)
self.mapWidget.addMapObject(polygon)
def drawCircle(self):
if not len(self.markerObjects):
return
p1 = self.markerObjects[0]
center = p1.coordinate()
radius = 3000 # Meters
if len(self.markerObjects) >= 2:
radius = center.distanceTo(self.markerObjects[1].coordinate())
pen = QPen(Qt.white)
pen.setWidth(2)
pen.setCosmetic(True)
circle = QGeoMapCircleObject(center, radius)
circle.setPen(pen)
fill = QColor(Qt.black)
fill.setAlpha(65)
circle.setBrush(QBrush(fill))
self.mapWidget.addMapObject(circle)
def drawText(self):
if not len(self.markerObjects):
return
start = self.markerObjects[0].coordinate()
text = QGeoMapTextObject(start, 'Text')
fill = QColor(Qt.black)
text.setBrush(fill)
self.mapWidget.addMapObject(text)
def calculateRoute(self):
if len(self.markerObjects) < 2:
return
waypoints = [x.coordinate() for x in self.markerObjects[:2]]
request = QGeoRouteRequest(waypoints)
self.routeReply = self.routingManager.calculateRoute(request)
self.routeReply.finished.connect(self.routeFinished)
def routeFinished(self):
if not self.routeReply.routes():
return
route = QGeoMapRouteObject(self.routeReply.routes()[0])
routeColor = QColor(Qt.blue)
routeColor.setAlpha(127)
pen = QPen(routeColor)
pen.setWidth(7)
pen.setCosmetic(True)
pen.setCapStyle(Qt.RoundCap)
route.setPen(pen)
self.mapWidget.addMapObject(route)
def drawPixmap(self):
marker = QGeoMapPixmapObject(self.mapWidget.screenPositionToCoordinate(self.lastClicked),
QPoint(-(MARKER_WIDTH / 2), -MARKER_HEIGHT), self.markerIcon)
self.mapWidget.addMapObject(marker)
self.markerObjects.append(marker)
def removePixmaps(self):
for i in range(len(self.markerObjects)):
marker = self.markerObjects.pop()
self.mapWidget.removeMapObject(marker)
marker.deleteLater()
def customContextMenuRequest(self, point):
self.lastClicked = point
if self.focusWidget() == self.view:
if not self.popupMenu:
self.createMenus()
self.popupMenu.popup(self.view.mapToGlobal(self.lastClicked))
def __init__(self, parent=None, filePath=''):
"""Default class constructor."""
super(MDISubWindow_TextEdit, self).__init__(parent)
print(filePath)
self.filePath = filePath
self.fileName = os.path.basename(os.path.abspath(filePath))
self.fileExt = os.path.splitext(self.fileName)[1]
if not filePath:
self.setWindowTitle('Untitled[*]')
parent.setWindowIcon(QIcon(gIconDir + os.sep + 'new.png'))
else:
f = open(filePath, 'r')
txt = f.read()
f.close()
self.setText(txt)
self.setWindowTitle('%s[*]' % self.fileName)
# TODO: This is changing all the subwindows icons. We want individual icons based on filetype...?
if self.fileExt in ('.py', '.pyw'):
parent.setWindowIcon(QIcon(gIconDir + os.sep + 'pyscript.png'))
else:
parent.setWindowIcon(QIcon(gIconDir + os.sep + 'new.png'))
monoFont = QFont('Courier New')
monoFont.setFixedPitch(True)
self.setFont(monoFont)
self.setWordWrapMode(QTextOption.NoWrap)
## self.setTextBackgroundColor(QColor('#000000'))
## self.setTextColor(QColor('#FFFFFF'))
self.setCursorWidth(2)
self.CreateActions()
self.zoomLevel = 0
gMainWin.action_Edit_Cut.setEnabled(False)
gMainWin.action_Edit_Copy.setEnabled(False)
self.copyAvailable.connect(gMainWin.action_Edit_Cut.setEnabled)
self.copyAvailable.connect(gMainWin.action_Edit_Copy.setEnabled)
# Handle the Context Menu Entries Also.
self.action_Edit_Undo.setEnabled(False)
self.action_Edit_Redo.setEnabled(False)
self.action_Edit_Cut.setEnabled(False)
self.action_Edit_Copy.setEnabled(False)
self.undoAvailable.connect(self.action_Edit_Undo.setEnabled)
self.redoAvailable.connect(self.action_Edit_Redo.setEnabled)
self.copyAvailable.connect(self.action_Edit_Cut.setEnabled)
self.copyAvailable.connect(self.action_Edit_Copy.setEnabled)
self.document().contentsChanged.connect(self.TheDocumentWasModified)
# self.show()
# self.showMaximized()
# self.setFocusPolicy(Qt.WheelFocus)
##### self.setFocus() # This makes the MDIArea go into SubWindowView...?
self.gCornerWidget = QToolButton(self)
# self.gCornerWidgetToolTip = QToolTip()
QToolTip.setFont(QFont('SansSerif', 10))
br = QBrush(QPixmap(gImgDir + os.sep + 'texture-spirals.png'))
pal = QPalette()
# pal.setBrush(QPalette.Active, QPalette.Base, br)
# pal.setColor(QPalette.Background, QColor('#FF8000'))
pal.setColor(QPalette.ColorGroup.Inactive,
QPalette.ColorRole.ToolTipBase, QColor(EMBROIDERBLUE2))
QToolTip.setPalette(QPalette(pal))
self.action_Edit_SelectAll.setToolTip(
'This is a <b>QWidget</b> widget')
self.gCornerWidget.setDefaultAction(self.action_Edit_SelectAll)
self.setCornerWidget(self.gCornerWidget)
# We want to show the corner widget no matter what so...
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
class MDISubWindow_TextEdit(QTextEdit):
documentCount = 1
def __init__(self, parent=None, filePath=''):
"""Default class constructor."""
super(MDISubWindow_TextEdit, self).__init__(parent)
print(filePath)
self.filePath = filePath
self.fileName = os.path.basename(os.path.abspath(filePath))
self.fileExt = os.path.splitext(self.fileName)[1]
if not filePath:
self.setWindowTitle('Untitled[*]')
parent.setWindowIcon(QIcon(gIconDir + os.sep + 'new.png'))
else:
f = open(filePath, 'r')
txt = f.read()
f.close()
self.setText(txt)
self.setWindowTitle('%s[*]' % self.fileName)
# TODO: This is changing all the subwindows icons. We want individual icons based on filetype...?
if self.fileExt in ('.py', '.pyw'):
parent.setWindowIcon(QIcon(gIconDir + os.sep + 'pyscript.png'))
else:
parent.setWindowIcon(QIcon(gIconDir + os.sep + 'new.png'))
monoFont = QFont('Courier New')
monoFont.setFixedPitch(True)
self.setFont(monoFont)
self.setWordWrapMode(QTextOption.NoWrap)
## self.setTextBackgroundColor(QColor('#000000'))
## self.setTextColor(QColor('#FFFFFF'))
self.setCursorWidth(2)
self.CreateActions()
self.zoomLevel = 0
gMainWin.action_Edit_Cut.setEnabled(False)
gMainWin.action_Edit_Copy.setEnabled(False)
self.copyAvailable.connect(gMainWin.action_Edit_Cut.setEnabled)
self.copyAvailable.connect(gMainWin.action_Edit_Copy.setEnabled)
# Handle the Context Menu Entries Also.
self.action_Edit_Undo.setEnabled(False)
self.action_Edit_Redo.setEnabled(False)
self.action_Edit_Cut.setEnabled(False)
self.action_Edit_Copy.setEnabled(False)
self.undoAvailable.connect(self.action_Edit_Undo.setEnabled)
self.redoAvailable.connect(self.action_Edit_Redo.setEnabled)
self.copyAvailable.connect(self.action_Edit_Cut.setEnabled)
self.copyAvailable.connect(self.action_Edit_Copy.setEnabled)
self.document().contentsChanged.connect(self.TheDocumentWasModified)
# self.show()
# self.showMaximized()
# self.setFocusPolicy(Qt.WheelFocus)
##### self.setFocus() # This makes the MDIArea go into SubWindowView...?
self.gCornerWidget = QToolButton(self)
# self.gCornerWidgetToolTip = QToolTip()
QToolTip.setFont(QFont('SansSerif', 10))
br = QBrush(QPixmap(gImgDir + os.sep + 'texture-spirals.png'))
pal = QPalette()
# pal.setBrush(QPalette.Active, QPalette.Base, br)
# pal.setColor(QPalette.Background, QColor('#FF8000'))
pal.setColor(QPalette.ColorGroup.Inactive,
QPalette.ColorRole.ToolTipBase, QColor(EMBROIDERBLUE2))
QToolTip.setPalette(QPalette(pal))
self.action_Edit_SelectAll.setToolTip(
'This is a <b>QWidget</b> widget')
self.gCornerWidget.setDefaultAction(self.action_Edit_SelectAll)
self.setCornerWidget(self.gCornerWidget)
# We want to show the corner widget no matter what so...
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
def CreateActions(self):
self.action_Edit_Undo = QAction(
QIcon(gIconDir + os.sep + 'undo.png'),
self.tr('&Undo'),
self,
shortcut=UndoShortcut, # QKeySequence.Undo
statusTip=self.tr('Reverses the most recent action.'),
triggered=self.undo)
self.action_Edit_Redo = QAction(
QIcon(gIconDir + os.sep + 'redo.png'),
self.tr('&Redo'),
self,
shortcut=RedoShortcut, # QKeySequence.Redo
statusTip=self.tr(
'Reverses the effects of the previous undo action.'),
triggered=self.redo)
self.action_Edit_Cut = QAction(
QIcon(gIconDir + os.sep + 'cut.png'),
self.tr('Cu&t'),
self,
shortcut=CutShortcut, # QKeySequence.Cut
statusTip=self.tr(
'Cut the current selection\'s contents to the clipboard.'),
triggered=self.cut)
self.action_Edit_Copy = QAction(
QIcon(gIconDir + os.sep + 'copy.png'),
self.tr('&Copy'),
self,
shortcut=CopyShortcut, # QKeySequence.Copy
statusTip=self.tr(
'Copy the current selection\'s contents to the clipboard.'),
triggered=self.copy)
self.action_Edit_Paste = QAction(
QIcon(gIconDir + os.sep + 'paste.png'),
self.tr('&Paste'),
self,
shortcut=PasteShortcut, # QKeySequence.Paste
statusTip=self.tr(
'Paste the clipboard\'s contents into the current selection.'),
triggered=self.paste)
self.action_Edit_Delete = QAction(
QIcon(gIconDir + os.sep + 'delete.png'),
self.tr('&Delete'),
self,
# shortcut=DeleteShortcut, # QKeySequence.Delete
statusTip=self.tr('Delete selection.'),
triggered=gMainWin.OnTODO)
# triggered=self.delete)
self.action_Edit_SelectAll = QAction(
QIcon(gIconDir + os.sep + 'selectall.png'),
self.tr('&Select All'),
self,
# shortcut=SelectAllShortcut, # QKeySequence.SelectAll
statusTip=self.tr('Select all text in the document.'),
# toolTip=QToolTip.text('Select All'),
triggered=self.selectAll)
self.action_Edit_ZoomIn = QAction(
QIcon(gIconDir + os.sep + 'zoomin.png'),
self.tr('Zoom &In'),
self,
shortcut=QKeySequence.ZoomIn, # ZoomInShortcut,
statusTip=self.tr('Zoom In'),
triggered=self.DoZoomIn)
self.action_Edit_ZoomOut = QAction(
QIcon(gIconDir + os.sep + 'zoomout.png'),
self.tr('Zoom &Out'),
self,
shortcut=QKeySequence(
Qt.CTRL +
Qt.Key_Plus), #QKeySequence.ZoomOut, # ZoomOutShortcut,
statusTip=self.tr('Zoom Out'),
triggered=self.DoZoomOut)
self.action_Edit_ZoomDefault = QAction(
QIcon(gIconDir + os.sep + 'zoom.png'),
self.tr('Zoom &Default'),
self,
shortcut=ZoomDefaultShortcut,
statusTip=self.tr('Zoom Default'),
triggered=self.DoZoomDefault)
def TheDocumentWasModified(self):
""""""
self.setWindowModified(self.document().isModified())
# def focusInEvent(self, event):
# event.accept()
# event.ignore()
# print('focusInEvent - ')
def AskToSaveBeforeClosing(self):
""""""
if self.document().isModified():
ret = QMessageBox.warning(
self, 'Warning', 'The document has been modified.'
'\n'
'Do you want to save your changes?',
QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)
if ret == QMessageBox.Save:
return self.OnSave()
elif ret == QMessageBox.Cancel:
if gMainWin.isEmbroidermodderMainWindowClosing:
gMainWin.isEmbroidermodderMainWindowClosing = False # Cancel closing the app.
return False
return True
def OnSave(self):
""""""
if self.filePath:
return self.OnSaveFilePath(self.filePath)
return self.OnSaveAs()
def OnSaveAs(self):
""""""
filePath, filtr = QFileDialog.getSaveFileName(self,
self.tr('Save As...'),
os.getcwd(),
WILDCARD_ALL)
if filePath:
return self.OnSaveFilePath(filePath)
return False
def OnSaveFilePath(self, filePath):
""""""
file = QFile(filePath)
if not file.open(QFile.WriteOnly | QFile.Text):
QMessageBox.warning(
self, self.tr('Warning'),
self.tr('Cannot write file') + ' %s:\n%s.' %
(filePath, file.errorString()))
return False
outf = QTextStream(file)
QApplication.setOverrideCursor(Qt.WaitCursor)
outf << self.toPlainText()
QApplication.restoreOverrideCursor()
self.DoSetCurrentFilePath(filePath)
# Clear the Modified Flag.
self.document().setModified(False)
self.setWindowModified(False)
self.setWindowTitle('%s[*]' % self.fileName)
return True
def OnPrint(self):
""""""
document = self.document()
printer = QPrinter()
dlg = QPrintDialog(printer, self)
if dlg.exec_() != QDialog.Accepted:
return
document.print_(printer)
def contextMenuEvent(self, event):
"""
Handles the ``contextMenuEvent`` event for :class:`MDISubWindow_TextEdit`.
:param `event`: a `QContextMenuEvent` event to be processed.
"""
menu = QMenu(self)
menu.addAction(self.action_Edit_Undo)
menu.addAction(self.action_Edit_Redo)
menu.addSeparator()
menu.addAction(self.action_Edit_Cut)
menu.addAction(self.action_Edit_Copy)
menu.addAction(self.action_Edit_Paste)
menu.addAction(self.action_Edit_Delete)
menu.addSeparator()
menu.addAction(self.action_Edit_SelectAll)
menu.popup(self.mapToGlobal(event.pos()))
# menu.exec_(self.mapToGlobal(event.pos()))
event.accept()
print("MDISubWindow_TextEdit contextMenuEvent")
def DoZoomOut(self):
""""""
self.zoomOut()
self.zoomLevel = self.zoomLevel - 1
def DoZoomIn(self):
""""""
self.zoomIn()
self.zoomLevel = self.zoomLevel + 1
def GetZoomLevel(self):
""""""
return self.zoomLevel
def DoZoomDefault(self):
""""""
if self.zoomLevel: # not == 0
if self.zoomLevel < 0:
while self.GetZoomLevel():
self.DoZoomIn()
else:
while self.GetZoomLevel():
self.DoZoomOut()
def OnDay(self):
""""""
self.setTextBackgroundColor(QColor('#FFFFFF'))
self.setTextColor(QColor('#000000'))
print('OnDay')
def OnNight(self):
""""""
self.setTextBackgroundColor(QColor('#000000'))
# self.setTextColor(QColor('#FFFFFF'))
# sample_palette = QPalette()
# sample_palette.setColor(QPalette.Window, Qt.white)
# sample_palette.setColor(QPalette.WindowText, Qt.blue)
# self.setAutoFillBackground(True)
# self.setPalette(sample_palette)
self.document().setDefaultStyleSheet(
"QTextEdit {color: white; background-color: black}")
# self.setStyleSheet("color: white; background-color: black")
# self.setStyleSheet("color: white;"
# "background-color: black;"
# "selection-color: black;"
# "selection-background-color: white;")
# self.setExtraSelections([(0, 1)])
# self.setAutoFillBackground(True)
# self.setBackgroundRole(QPalette.Background)
self.update()
print('OnNight')
def wheelEvent(self, event):
""""""
evtDelta = event.delta()
evtModifiers = event.modifiers()
evtAltDown = evtModifiers & Qt.AltModifier
evtShiftDown = evtModifiers & Qt.ShiftModifier
evtCtrlDown = evtModifiers & Qt.ControlModifier
## print('evtModifiers = %s' % evtModifiers)
## print('evtAltDown = %s' % evtAltDown)
## print('evtShiftDown = %s' % evtShiftDown)
## print('evtCtrlDown = %s' % evtCtrlDown)
## print('event.delta() = %s' % evtDelta)
# Ctrl+MouseWheel Zooming.
if (evtDelta <
0) and evtCtrlDown and not evtShiftDown and not evtAltDown:
if self.zoomLevel > -7:
self.DoZoomOut()
print('zoomLevel = %d' % self.zoomLevel)
elif (evtDelta >
0) and evtCtrlDown and not evtShiftDown and not evtAltDown:
if self.zoomLevel < 20:
self.DoZoomIn()
print('zoomLevel = %d' % self.zoomLevel)
# Shift+MouseWheel Horizontal Scrolling.
elif (evtDelta <
0) and not evtCtrlDown and evtShiftDown and not evtAltDown:
self.horizontalScrollBar().triggerAction(
QAbstractSlider.SliderSingleStepAdd)
self.horizontalScrollBar().triggerAction(
QAbstractSlider.SliderSingleStepAdd)
elif (evtDelta >
0) and not evtCtrlDown and evtShiftDown and not evtAltDown:
self.horizontalScrollBar().triggerAction(
QAbstractSlider.SliderSingleStepSub)
self.horizontalScrollBar().triggerAction(
QAbstractSlider.SliderSingleStepSub)
# Reproduce Regular Scrolling.
elif evtDelta < 0:
self.verticalScrollBar().triggerAction(
QAbstractSlider.SliderSingleStepAdd)
self.verticalScrollBar().triggerAction(
QAbstractSlider.SliderSingleStepAdd)
elif evtDelta > 0:
self.verticalScrollBar().triggerAction(
QAbstractSlider.SliderSingleStepSub)
self.verticalScrollBar().triggerAction(
QAbstractSlider.SliderSingleStepSub)
event.accept()
# event.ignore()
# numDegrees = event.delta() / 8
# numSteps = numDegrees / 15
# print('numDegrees = %s' % numDegrees)
# print('numSteps = %s' % numSteps)
#if event.orientation() == Qt.Horizontal:
# self.scroll(numSteps, 0)
# # self.scrollHorizontally(numSteps)
#else:
# self.scroll(0, numSteps)
# # self.scrollVertically(numSteps)
#event.accept()
def DoSetCurrentFilePath(self, filePath):
""""""
self.filePath = str(filePath)
self.fileName = os.path.basename(os.path.abspath(filePath))
self.fileExt = os.path.splitext(self.fileName)[1]
def closeEvent(self, event):
""""""
if self.AskToSaveBeforeClosing():
# self.DoWriteSettings()
event.accept()
else:
event.ignore()
def createToolsButtons(self):
buttonsFrame = QFrame()
buttonsLayout = QHBoxLayout(buttonsFrame)
buttonsLayout.setSizeConstraint(QLayout.SetDefaultConstraint)
iconPath = filePath('icons/')
self.penButton = QToolButton(
self,
icon=QIcon(iconPath + 'pen_w.png'))
self.penButton.setToolTip('freehand drawing')
self.penButton.clicked.connect(lambda: self.PaintArea.setTool('pen'))
buttonsLayout.addWidget(self.penButton)
self.lineButton = QToolButton(
self,
icon=QIcon(iconPath + 'line_w.png'))
self.lineButton.setToolTip('draw lines')
self.lineButton.clicked.connect(lambda: self.PaintArea.setTool('line'))
buttonsLayout.addWidget(self.lineButton)
self.rect = QToolButton(
self,
icon=QIcon(iconPath + 'rect_w.png'))
self.rect.setToolTip('create rectangle')
self.rect.clicked.connect(lambda: self.PaintArea.setTool('rect'))
buttonsLayout.addWidget(self.rect)
self.roundRect = QToolButton(
self,
icon=QIcon(iconPath + 'roundrect_w.png'))
self.roundRect.setToolTip('create a round-corner rectanlge')
self.roundRect.clicked.connect(
lambda: self.PaintArea.setTool('roundRect'))
buttonsLayout.addWidget(self.roundRect)
self.circle = QToolButton(
self,
icon=QIcon(iconPath + 'ellipse_w.png'))
self.circle.setToolTip('create circle')
self.circle.clicked.connect(lambda: self.PaintArea.setTool('circle'))
buttonsLayout.addWidget(self.circle)
self.eraser = QToolButton(
self,
icon=QIcon(iconPath + 'eraser_w.png'))
self.eraser.setToolTip('erase parts of the drawing')
self.eraser.clicked.connect(lambda: self.PaintArea.setTool('eraser'))
buttonsLayout.addWidget(self.eraser)
self.mirror_w = QToolButton(
self,
icon=QIcon(iconPath + 'mirror-w_w.png'))
self.mirror_w.setToolTip('vertical symmetric inversion')
self.mirror_w.clicked.connect(self.PaintArea.mirror_w)
buttonsLayout.addWidget(self.mirror_w)
self.mirror_h = QToolButton(
self,
icon=QIcon(iconPath + 'mirror-h_w.png'))
self.mirror_h.setToolTip('horizontal symmetric inversion')
self.mirror_h.clicked.connect(self.PaintArea.mirror_h)
buttonsLayout.addWidget(self.mirror_h)
self.rotate = QToolButton(
self,
icon=QIcon(iconPath + 'rotate_w.png'))
self.rotate.setToolTip('rotate')
self.rotate.clicked.connect(self.PaintArea.rotate)
buttonsLayout.addWidget(self.rotate)
self.grid.addWidget(buttonsFrame, 0, 0, QtCore.Qt.AlignLeft)
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
lbMinWidth = 65
# leMinWidth = 200
MainWindow.setObjectName("MainWindow")
MainWindow.resize(400, 310)
# self.centralwidget = QWidget(MainWindow)
self.mainSplitter = QSplitter(Qt.Horizontal, MainWindow)
self.mainSplitter.setObjectName("centralwidget")
self.mainSplitter.setProperty("childrenCollapsible", False)
MainWindow.setCentralWidget(self.mainSplitter)
self.leftSplitter = QSplitter(Qt.Vertical, self.mainSplitter)
self.leftSplitter.setProperty("childrenCollapsible", False)
##### login_gbox
self.login_gbox = QGroupBox(self.leftSplitter)
self.login_gbox.setFlat(True)
self.login_gbox.setObjectName("login_gbox")
login_gbox_layout = QVBoxLayout(self.login_gbox)
login_gbox_csf_layout = QHBoxLayout()
login_gbox_account_layout = QHBoxLayout()
login_gbox_connect_layout = QHBoxLayout()
login_gbox_layout.addLayout(login_gbox_csf_layout)
login_gbox_layout.addLayout(login_gbox_account_layout)
login_gbox_layout.addLayout(login_gbox_connect_layout)
self.lb_client_secrets_file_path = QLabel(self.login_gbox)
self.lb_client_secrets_file_path.setObjectName("lb_client_secrets_file_path")
self.lb_client_secrets_file_path.setMinimumWidth(lbMinWidth)
self.client_secrets_file_path_le = QLineEdit(self.login_gbox)
self.client_secrets_file_path_le.setObjectName("client_secrets_file_path_le")
self.client_secret_file_path_tBtn = QToolButton(self.login_gbox)
self.client_secret_file_path_tBtn.setObjectName("client_secret_file_path_tBtn")
login_gbox_csf_layout.addWidget(self.lb_client_secrets_file_path)
login_gbox_csf_layout.addWidget(self.client_secrets_file_path_le)
login_gbox_csf_layout.addWidget(self.client_secret_file_path_tBtn)
self.lb_account = QLabel(self.login_gbox)
self.lb_account.setMaximumWidth(lbMinWidth)
self.lb_account.setObjectName("lb_account")
self.remove_account_btn = QToolButton(self.login_gbox)
self.remove_account_btn.setObjectName("remove_account_btn")
self.remove_account_btn.setMinimumWidth(20)
self.remove_account_btn.setEnabled(False)
self.add_account_btn = QToolButton(self.login_gbox)
self.add_account_btn.setObjectName("add_account_btn")
self.add_account_btn.setMinimumWidth(20)
self.accounts_cb = QComboBox(self.login_gbox)
self.accounts_cb.setObjectName("accounts_cb")
login_gbox_account_layout.addWidget(self.lb_account)
login_gbox_account_layout.addWidget(self.remove_account_btn)
login_gbox_account_layout.addWidget(self.add_account_btn)
login_gbox_account_layout.addWidget(self.accounts_cb)
self.lb_decryption_key = QLabel(self.login_gbox)
self.lb_decryption_key.setObjectName("lb_decryption_key")
self.lb_decryption_key.setMinimumWidth(lbMinWidth)
self.lb_decryption_key.hide()
self.decryption_key_le = QLineEdit(self.login_gbox)
self.decryption_key_le.setEchoMode(QLineEdit.Password)
self.decryption_key_le.setObjectName("decryption_key_le")
self.decryption_key_le.hide()
self.connect_btn = QPushButton(self.login_gbox)
self.connect_btn.setEnabled(False)
self.connect_btn.setObjectName("connect_btn")
login_gbox_connect_layout.addWidget(self.lb_decryption_key)
login_gbox_connect_layout.addWidget(self.decryption_key_le)
login_gbox_connect_layout.addWidget(self.connect_btn)
#### search_gbox
self.search_gbox = QGroupBox(self.leftSplitter)
self.search_gbox.setFlat(True)
self.search_gbox.setObjectName("search_gbox")
self.search_gbox.hide()
search_gbox_layout = QVBoxLayout(self.search_gbox)
search_gbox_mailbox_layout = QVBoxLayout()
search_gbox_date_layout = QHBoxLayout()
search_gbox_from_layout = QHBoxLayout()
search_gbox_to_layout = QHBoxLayout()
search_gbox_subject_layout = QHBoxLayout()
search_gbox_threads_layout = QHBoxLayout()
search_gbox_paramaters_layout = QHBoxLayout()
search_gbox_layout.addLayout(search_gbox_mailbox_layout)
search_gbox_layout.addLayout(search_gbox_date_layout)
search_gbox_layout.addLayout(search_gbox_from_layout)
search_gbox_layout.addLayout(search_gbox_to_layout)
search_gbox_layout.addLayout(search_gbox_subject_layout)
search_gbox_layout.addLayout(search_gbox_threads_layout)
search_gbox_layout.addLayout(search_gbox_paramaters_layout)
self.lb_select_mailbox = QLabel(self.search_gbox)
self.lb_select_mailbox.setObjectName("lb_select_mailbox")
self.mailboxes_lw = QListWidget(self.search_gbox)
self.mailboxes_lw.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.mailboxes_lw.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.mailboxes_lw.setObjectName("mailboxes_lw")
search_gbox_mailbox_layout.addWidget(self.lb_select_mailbox)
search_gbox_mailbox_layout.addWidget(self.mailboxes_lw)
self.after_date_cb = QCheckBox(self.search_gbox)
self.after_date_cb.setObjectName("after_date_cb")
self.after_date_cb.setMinimumWidth(lbMinWidth)
self.after_date_cb.setMaximumWidth(lbMinWidth)
self.after_date_edit = QDateEdit(self.search_gbox)
self.after_date_edit.setCalendarPopup(True)
self.after_date_edit.setObjectName("after_date_edit")
self.after_date_edit.setDate(QDate.currentDate().addDays(-365))
self.after_date_edit.setMaximumDate(QDate.currentDate())
self.after_date_edit.setEnabled(False)
self.before_date_cb = QCheckBox(self.search_gbox)
self.before_date_cb.setObjectName("before_date_cb")
self.before_date_cb.setMinimumWidth(70)
self.before_date_cb.setMaximumWidth(70)
self.before_date_edit = QDateEdit(self.search_gbox)
self.before_date_edit.setCalendarPopup(True)
self.before_date_edit.setObjectName("before_date_edit")
self.before_date_edit.setDate(QDate.currentDate())
self.before_date_edit.setMaximumDate(QDate.currentDate())
self.before_date_edit.setEnabled(False)
search_gbox_date_layout.addWidget(self.after_date_cb)
search_gbox_date_layout.addWidget(self.after_date_edit)
search_gbox_date_layout.addWidget(self.before_date_cb)
search_gbox_date_layout.addWidget(self.before_date_edit)
self.lb_from = QLabel(self.search_gbox)
self.lb_from.setObjectName("lb_from")
self.lb_from.setMinimumWidth(lbMinWidth)
self.from_le = QLineEdit(self.search_gbox)
self.from_le.setObjectName("from_le")
search_gbox_from_layout.addWidget(self.lb_from)
search_gbox_from_layout.addWidget(self.from_le)
self.lb_to = QLabel(self.search_gbox)
self.lb_to.setObjectName("lb_to")
self.lb_to.setMinimumWidth(lbMinWidth)
self.to_le = QLineEdit(self.search_gbox)
self.to_le.setObjectName("to_le")
search_gbox_to_layout.addWidget(self.lb_to)
search_gbox_to_layout.addWidget(self.to_le)
self.lb_subject = QLabel(self.search_gbox)
self.lb_subject.setObjectName("lb_subject")
self.lb_subject.setMinimumWidth(lbMinWidth)
self.subject_le = QLineEdit(self.search_gbox)
self.subject_le.setObjectName("subject_le")
search_gbox_subject_layout.addWidget(self.lb_subject)
search_gbox_subject_layout.addWidget(self.subject_le)
self.lb_threads = QLabel(self.search_gbox)
self.lb_threads.setObjectName("lb_threads")
self.lb_threads.setMaximumWidth(lbMinWidth)
self.thread_count_sb = QSpinBox(self.search_gbox)
self.thread_count_sb.setMinimum(1)
self.thread_count_sb.setMaximum(10)
self.thread_count_sb.setObjectName("thread_count_sb")
self.html_radio = QRadioButton(self.search_gbox)
self.html_radio.setObjectName("html_radio")
self.text_radio = QRadioButton(self.search_gbox)
self.text_radio.setObjectName("text_radio")
self.extactTypeButtonGroup = QButtonGroup(self)
self.extactTypeButtonGroup.addButton(self.html_radio)
self.extactTypeButtonGroup.addButton(self.text_radio)
self.html_radio.setChecked(True)
self.search_btn = QPushButton(self.search_gbox)
self.search_btn.setObjectName("search_btn")
search_gbox_threads_layout.addWidget(self.lb_threads)
search_gbox_threads_layout.addWidget(self.thread_count_sb)
search_gbox_threads_layout.addWidget(self.html_radio)
search_gbox_threads_layout.addWidget(self.text_radio)
search_gbox_threads_layout.addWidget(self.search_btn)
self.parameters_cb = QCheckBox(self.search_gbox)
self.parameters_cb.setText("")
self.parameters_cb.setObjectName("parameters_cb")
self.parameters_le = QLineEdit(self.search_gbox)
self.parameters_le.setEnabled(False)
self.parameters_le.setObjectName("parameters_le")
search_gbox_paramaters_layout.addWidget(self.parameters_cb)
search_gbox_paramaters_layout.addWidget(self.parameters_le)
#### log_gbox
self.log_gbox = QGroupBox(self.leftSplitter)
self.log_gbox.setFlat(True)
self.log_gbox.setObjectName("log_gbox")
log_layout = QVBoxLayout(self.log_gbox)
self.log_te = QTextEdit(self.log_gbox)
self.log_te.setLineWrapMode(QTextEdit.NoWrap)
self.log_te.setReadOnly(True)
self.log_te.setTextInteractionFlags(Qt.TextSelectableByKeyboard | Qt.TextSelectableByMouse)
self.log_te.setObjectName("log_te")
self.disconnect_btn = QPushButton(self.log_gbox)
self.disconnect_btn.setObjectName("disconnect_btn")
self.disconnect_btn.hide()
log_layout.addWidget(self.log_te)
log_layout_btn = QHBoxLayout()
log_layout.addLayout(log_layout_btn)
log_layout_btn.addWidget(self.disconnect_btn)
log_layout_btn.addStretch()
#### links_gbox
self.links_gbox = QGroupBox(self.mainSplitter)
self.links_gbox.setFlat(True)
self.links_gbox.setObjectName("links_gbox")
self.links_gbox.hide()
links_gbox_layout = QVBoxLayout(self.links_gbox)
links_gbox_links_layout = QVBoxLayout()
links_gbox_buttons_layout = QHBoxLayout()
links_gbox_layout.addLayout(links_gbox_links_layout)
links_gbox_layout.addLayout(links_gbox_buttons_layout)
self.links_text_edit = QTextEdit(self.links_gbox)
self.links_text_edit.setObjectName("links_text_edit")
links_gbox_links_layout.addWidget(self.links_text_edit)
self.export_txt_btn = QPushButton(self.links_gbox)
self.export_txt_btn.setObjectName("export_txt_btn")
self.export_txt_btn.setEnabled(False)
self.export_html_btn = QPushButton(self.links_gbox)
self.export_html_btn.setObjectName("export_html_btn")
self.export_html_btn.setEnabled(False)
links_gbox_buttons_layout.addWidget(self.export_txt_btn)
links_gbox_buttons_layout.addWidget(self.export_html_btn)
### menubar
self.menubar = QMenuBar(MainWindow)
# self.menubar.setGeometry(QRect(0, 0, 860, 21))
self.menubar.setObjectName("menubar")
self.menu_file = QMenu(self.menubar)
self.menu_file.setObjectName("menu_file")
self.menu_help = QMenu(self.menubar)
self.menu_help.setObjectName("menu_help")
MainWindow.setMenuBar(self.menubar)
self.action_about = QAction(MainWindow)
self.action_about.setObjectName("action_about")
self.action_About_Qt = QAction(MainWindow)
self.action_About_Qt.setObjectName("action_About_Qt")
self.action_exit = QAction(MainWindow)
self.action_exit.setObjectName("action_exit")
self.actionSave = QAction(MainWindow)
self.actionSave.setObjectName("actionSave")
self.action_Gmail_Advanced_Search_Syntax = QAction(MainWindow)
self.action_Gmail_Advanced_Search_Syntax.setObjectName("action_Gmail_Advanced_Search_Syntax")
self.menu_file.addAction(self.action_exit)
self.menu_help.addAction(self.action_Gmail_Advanced_Search_Syntax)
self.menu_help.addSeparator()
self.menu_help.addAction(self.action_about)
self.menu_help.addAction(self.action_About_Qt)
self.menubar.addAction(self.menu_file.menuAction())
self.menubar.addAction(self.menu_help.menuAction())
self.retranslateUi(MainWindow)
QMetaObject.connectSlotsByName(MainWindow)
MainWindow.setTabOrder(self.client_secrets_file_path_le, self.client_secret_file_path_tBtn)
MainWindow.setTabOrder(self.client_secret_file_path_tBtn, self.remove_account_btn)
MainWindow.setTabOrder(self.remove_account_btn, self.add_account_btn)
MainWindow.setTabOrder(self.add_account_btn, self.accounts_cb)
MainWindow.setTabOrder(self.decryption_key_le, self.connect_btn)
MainWindow.setTabOrder(self.connect_btn, self.log_te)
MainWindow.setTabOrder(self.log_te, self.mailboxes_lw)
MainWindow.setTabOrder(self.mailboxes_lw, self.after_date_cb)
MainWindow.setTabOrder(self.after_date_cb, self.after_date_edit)
MainWindow.setTabOrder(self.after_date_edit, self.before_date_cb)
MainWindow.setTabOrder(self.before_date_cb, self.before_date_edit)
MainWindow.setTabOrder(self.before_date_edit, self.from_le)
MainWindow.setTabOrder(self.from_le, self.to_le)
MainWindow.setTabOrder(self.to_le, self.subject_le)
MainWindow.setTabOrder(self.subject_le, self.thread_count_sb)
MainWindow.setTabOrder(self.thread_count_sb, self.html_radio)
MainWindow.setTabOrder(self.html_radio, self.text_radio)
MainWindow.setTabOrder(self.text_radio, self.search_btn)
MainWindow.setTabOrder(self.search_btn, self.parameters_cb)
MainWindow.setTabOrder(self.parameters_cb, self.parameters_le)
MainWindow.setTabOrder(self.parameters_le, self.disconnect_btn)
MainWindow.setTabOrder(self.disconnect_btn, self.links_text_edit)
MainWindow.setTabOrder(self.links_text_edit, self.export_txt_btn)
MainWindow.setTabOrder(self.export_txt_btn, self.export_html_btn)
MainWindow.setTabOrder(self.export_html_btn, self.mailboxes_lw)
def retranslateUi(self, MainWindow):
MainWindow.setWindowTitle(QApplication.translate("MainWindow", "Gmail URL Parser", None, QApplication.UnicodeUTF8))
self.login_gbox.setTitle(QApplication.translate("MainWindow", " Client secrets file path ", None, QApplication.UnicodeUTF8))
self.client_secrets_file_path_le.setPlaceholderText(QApplication.translate("MainWindow", "Please select your client secrets file", None, QApplication.UnicodeUTF8))
self.lb_client_secrets_file_path.setText(QApplication.translate("MainWindow", "Path", None, QApplication.UnicodeUTF8))
self.connect_btn.setText(QApplication.translate("MainWindow", "Connect", None, QApplication.UnicodeUTF8))
self.client_secret_file_path_tBtn.setText(QApplication.translate("MainWindow", "...", None, QApplication.UnicodeUTF8))
self.lb_account.setText(QApplication.translate("MainWindow", "Account", None, QApplication.UnicodeUTF8))
self.add_account_btn.setText(QApplication.translate("MainWindow", "+", None, QApplication.UnicodeUTF8))
self.remove_account_btn.setText(QApplication.translate("MainWindow", "-", None, QApplication.UnicodeUTF8))
self.decryption_key_le.setPlaceholderText(QApplication.translate("MainWindow", "Decryption key", None, QApplication.UnicodeUTF8))
self.lb_decryption_key.setText(QApplication.translate("MainWindow", "Key", None, QApplication.UnicodeUTF8))
self.log_gbox.setTitle(QApplication.translate("MainWindow", " Log ", None, QApplication.UnicodeUTF8))
self.search_gbox.setTitle(QApplication.translate("MainWindow", " Search Parameters ", None, QApplication.UnicodeUTF8))
self.lb_to.setText(QApplication.translate("MainWindow", "To", None, QApplication.UnicodeUTF8))
self.lb_from.setText(QApplication.translate("MainWindow", "From", None, QApplication.UnicodeUTF8))
self.lb_subject.setText(QApplication.translate("MainWindow", "Subject", None, QApplication.UnicodeUTF8))
self.search_btn.setText(QApplication.translate("MainWindow", "Search", None, QApplication.UnicodeUTF8))
self.after_date_edit.setDisplayFormat(QApplication.translate("MainWindow", "yyyy-MM-dd", None, QApplication.UnicodeUTF8))
self.before_date_edit.setDisplayFormat(QApplication.translate("MainWindow", "yyyy-MM-dd", None, QApplication.UnicodeUTF8))
self.lb_select_mailbox.setToolTip(QApplication.translate("MainWindow", "<html><head/><body><p>Select multiple items to select labels</p></body></html>", None, QApplication.UnicodeUTF8))
self.lb_select_mailbox.setText(QApplication.translate("MainWindow", "Select Mailbox or Labels", None, QApplication.UnicodeUTF8))
self.after_date_cb.setText(QApplication.translate("MainWindow", "After", None, QApplication.UnicodeUTF8))
self.before_date_cb.setText(QApplication.translate("MainWindow", "Before", None, QApplication.UnicodeUTF8))
self.html_radio.setText(QApplication.translate("MainWindow", "html", None, QApplication.UnicodeUTF8))
self.text_radio.setText(QApplication.translate("MainWindow", "text", None, QApplication.UnicodeUTF8))
self.lb_threads.setText(QApplication.translate("MainWindow", "Threads", None, QApplication.UnicodeUTF8))
self.links_gbox.setTitle(QApplication.translate("MainWindow", " Links ", None, QApplication.UnicodeUTF8))
self.disconnect_btn.setText(QApplication.translate("MainWindow", "Disconnect", None, QApplication.UnicodeUTF8))
self.export_txt_btn.setText(QApplication.translate("MainWindow", "Export as txt", None, QApplication.UnicodeUTF8))
self.export_html_btn.setText(QApplication.translate("MainWindow", "Export as HTML", None, QApplication.UnicodeUTF8))
self.menu_file.setTitle(QApplication.translate("MainWindow", "File", None, QApplication.UnicodeUTF8))
self.menu_help.setTitle(QApplication.translate("MainWindow", "Help", None, QApplication.UnicodeUTF8))
self.action_about.setText(QApplication.translate("MainWindow", "About", None, QApplication.UnicodeUTF8))
self.action_About_Qt.setText(QApplication.translate("MainWindow", "About Qt", None, QApplication.UnicodeUTF8))
self.action_exit.setText(QApplication.translate("MainWindow", "Exit", None, QApplication.UnicodeUTF8))
self.action_exit.setShortcut(QApplication.translate("MainWindow", "Ctrl+Q", None, QApplication.UnicodeUTF8))
self.actionSave.setText(QApplication.translate("MainWindow", "Save", None, QApplication.UnicodeUTF8))
self.action_Gmail_Advanced_Search_Syntax.setText(QApplication.translate("MainWindow", "Gmail Advanced Search Syntax", None, QApplication.UnicodeUTF8))
def createWidgets(self):
self.helpButton = QToolButton()
self.helpButton.setIcon(QIcon(":/help.svg"))
self.helpButton.setFocusPolicy(Qt.NoFocus)
self.tooltips.append((self.helpButton, "Help on the Entry panel."))
self.addingLabel = Widgets.Label.HtmlLabel(CANCEL_ADD)
self.addingLabel.hide()
self.termLabel = QLabel("&Term")
self.termEdit = Widgets.LineEdit.HtmlLineEdit(self.state)
self.tooltips.append((self.termEdit, """\
<p><b>Term editor</b> (Alt+T)</p>
<p>The entry's term text styled (e.g., <b>bold</b>, <i>italic</i>), as
it should appear in the final index.</p>"""))
self.spellHighlighter = Widgets.SpellHighlighter.Highlighter(
self.state, self.termEdit.document())
self.termLabel.setBuddy(self.termEdit)
self.pagesLabel = QLabel("&Pages")
self.pagesEdit = Widgets.LineEdit.HtmlPagesLineEdit(self.state,
maxLines=3)
self.tooltips.append((self.pagesEdit, """\
<p><b>Pages editor</b> (Alt+P)</p>
<p>The entry's pages styled (e.g., <b>bold</b>, <i>italic</i>), as they
should appear in the final index.</p> <p>The pages are automatically
sorted, and exact duplicates are automatically removed.</p> <p>See also
<b>Index→Combine Overlapping Pages</b> and <b>Index→Renumber
Pages</b>.</p>"""))
self.pagesLabel.setBuddy(self.pagesEdit)
self.calcSortAsCheckBox = QCheckBox("&Automatically Calculate Sort As")
self.tooltips.append((self.calcSortAsCheckBox, """\
<p><b>Automatically Calculate Sort As</b> (Alt+A)</p>
<p>This checkbox controls how the Sort As text is created.</p>
<p>If checked, {} will either automatically create the sort as
text, or will present some choices from which to choose the sort as
text, depending on the term text.</p>
<p>If unchecked, the sort as text should be entered
manually.</p>""".format(QApplication.applicationName())))
self.calcSortAsCheckBox.setChecked(True)
self.sortAsHelpButton = QToolButton()
self.sortAsHelpButton.setIcon(QIcon(":/help.svg"))
self.sortAsHelpButton.setFocusPolicy(Qt.NoFocus)
self.tooltips.append(
(self.sortAsHelpButton, "Help on the Sort As text."))
self.sortAsEdit = Widgets.LineEdit.LineEdit(self.state)
self.tooltips.append((self.sortAsEdit, """\
<p><b>Sort As editor</b> (Alt+S)</p>
<p>The entry's sort as text.</p>
<p>If the <b>Automatically Calculate Sort As</b> checkbox is unchecked,
manually enter the sort as text to use for sorting the entry.</p>
<p>Main entry's are sorted using the sort as text, so it is easy to
force a non-standard ordering by entering a custom sort as text.</p>
<p>Subentries are also sorted using the sort as text, but the first word
of a subentry will be ignored for sorting purposes if it is in the
Ignore Subentry Function words list (see <b>Index→Ignore Subentry
Function words</b>) <i>and</i> the <b>Index→Options, Rules,
Ignore Subenty Function Words</b> checkbox is checked for this
index.</p>"""))
self.sortAsEdit.setEnabled(False)
self.sortAsLabel = QLabel("&Sort As")
self.sortAsLabel.setBuddy(self.sortAsEdit)
self.sortAsLabel.setEnabled(False)
self.xrefLabel = QLabel("&Cross-references")
self.xrefList = Widgets.List.HtmlListWidget(self.state, minLines=4)
self.tooltips.append((self.xrefList, """\
<p><b>Cross-references list</b> (Alt+C)</p>
<p>The list of the entry's see and see also cross-references, both
generic and to other entries.</p>
<p>To add a cross-reference to an entry, circle the <i>to</i> entry
(<b>Entry→Circle</b>), then go to the <i>from</i> entry and click
<img src=":/xref-add.svg" width={0} height={0}> or press
<b>Entry→Add Cross-reference</b> (See also the <b>Entry</b>
menu.)</p>""".format(TOOLTIP_IMAGE_SIZE)))
self.xrefLabel.setBuddy(self.xrefList)
self.notesLabel = QLabel("&Notes")
self.notesEdit = Widgets.LineEdit.MultilineHtmlEdit(self.state)
self.tooltips.append((self.notesEdit, """\
<p><b>Notes editor</b> (Alt+N)</p>
<p>The entry's notes.</p>
<p>The notes shown here are never output as part of
the index so may be freely used for any purpose.</p>
<p>If the notes facility isn't wanted, the notes can be hidden by
unchecking the <b>Index→Options, General, Show Notes</b>
checkbox.</p>"""))
self.notesLabel.setBuddy(self.notesEdit)
class Mixin:
def createWidgets(self):
rules = SortAs.RulesForName[Gopt.Default.SortAsRules]
self.sortAsRuleLabel = QLabel(LABEL_TEMPLATE.format(rules.abbrev))
self.tooltips.append((self.sortAsRuleLabel, Lib.rulesTip(rules.tip)))
self.modeLabel = QLabel()
self.statusbar.addPermanentWidget(self.modeLabel)
self.tooltips.append((self.modeLabel, """<p><b>Mode</b></p>
<p>{}'s current mode.</p>""".format(QApplication.applicationName())))
self.statusbar.addPermanentWidget(self.sortAsRuleLabel)
rules = Pages.RulesForName[Gopt.Default.PageRangeRules]
self.pageRangeRulesLabel = QLabel(LABEL_TEMPLATE.format(rules.abbrev))
self.tooltips.append(
(self.pageRangeRulesLabel, Lib.rulesTip(rules.tip, False)))
self.statusbar.addPermanentWidget(self.pageRangeRulesLabel)
self.countLabel = QLabel(COUNT_LABEL_TEMPLATE.format(0, 0, 0, 0))
self.tooltips.append((self.countLabel, """<p><b>Counts</b></p>
<p>Counts of entries in the current index.</p>"""))
self.statusbar.addPermanentWidget(self.countLabel)
self.worktimeLabel = QLabel()
self.tooltips.append((self.worktimeLabel, """<p><b>Work Time</b></p>
<p>How many hours and minutes have been spent on this index.</p>"""))
self.statusbar.addPermanentWidget(self.worktimeLabel)
self.languageLabel = QLabel()
self.tooltips.append((self.languageLabel, """<p><b>Language</b></p>
<p>The language used for spelling and suggestions for this index.</p>"""))
self.statusbar.addPermanentWidget(self.languageLabel)
self.state.viewAllPanel = ViewAllPanel.Panel(self.state)
self.state.replacePanel = ReplacePanel.Panel(self.state)
self.state.replacePanel.closeButton.clicked.connect(self.closeReplace)
self.state.viewFilteredPanel = ViewFilteredPanel.Panel(self.state)
# Above must precede EntryPanel
self.state.entryPanel = EntryPanel.Panel(self.state, self)
# SpellPanel depends on EntryPanel and entryActions
self.entryActions = Actions.Entry.Actions(self)
self.state.spellPanel = SpellPanel.Panel(self.state, self)
self.state.groupsPanel = GroupsPanel.Panel(self.state, self)
self.state.entryPanel.populateEditors(self.state.editors)
def widgets(self):
return (self.state.viewAllPanel, self.state.replacePanel,
self.state.viewFilteredPanel, self.state.entryPanel,
self.state.spellPanel, self.state.groupsPanel, self.menuBar(),
self.fileToolBar, self.editToolBar, self.spellingToolBar,
self.formatToolBar, self.indexToolBar, self.entryToolBar1,
self.entryToolBar2, self.modifyToolBar, self.gotoToolBar1,
self.gotoToolBar2, self.gotoToolBar4, self.gotoToolBar3)
def closeReplace(self):
self.state.replacePanel.stop()
sizes = self.viewSplitter.sizes()
self.viewSplitter.setSizes([sum(sizes), 0])
def closeSuggestions(self):
sizes = self.spellAndGroupsSplitter.sizes()
if 0 in sizes:
sizes = self.entrySuggestionSplitter.sizes()
self.entrySuggestionSplitter.setSizes([sum(sizes), 0])
else:
self.spellAndGroupsSplitter.setSizes([0, sum(sizes)])
def closeGroups(self):
sizes = self.spellAndGroupsSplitter.sizes()
if 0 in sizes:
sizes = self.entrySuggestionSplitter.sizes()
self.entrySuggestionSplitter.setSizes([sum(sizes), 0])
else:
self.spellAndGroupsSplitter.setSizes([sum(sizes), 0])
def showSuggestions(self):
sizes = self.entrySuggestionSplitter.sizes()
quarter = sum(sizes) // 4
self.entrySuggestionSplitter.setSizes([quarter * 3, quarter])
half = sum(self.spellAndGroupsSplitter.sizes()) // 2
self.spellAndGroupsSplitter.setSizes([half, half])
def layoutWidgets(self):
self.panelSplitter = Widgets.Splitter.Splitter(Qt.Vertical)
self.entrySuggestionSplitter = Widgets.Splitter.Splitter(Qt.Horizontal)
self.entrySuggestionSplitter.addWidget(self.state.entryPanel)
self.spellAndGroupsSplitter = Widgets.Splitter.Splitter(Qt.Vertical)
self.spellAndGroupsSplitter.addWidget(self.state.spellPanel)
self.spellAndGroupsSplitter.addWidget(self.state.groupsPanel)
self.entrySuggestionSplitter.addWidget(self.spellAndGroupsSplitter)
self.entrySuggestionSplitter.setCollapsible(0, False)
self.entrySuggestionSplitter.setCollapsible(1, True)
self.entrySuggestionSplitter.setStretchFactor(0, 3)
self.entrySuggestionSplitter.setStretchFactor(1, 1)
self.panelSplitter.addWidget(self.entrySuggestionSplitter)
self.panelSplitter.addWidget(self.state.viewFilteredPanel)
self.panelSplitter.setCollapsible(0, False)
self.panelSplitter.setCollapsible(0, False)
self.viewSplitter = Widgets.Splitter.Splitter(Qt.Vertical)
self.viewSplitter.addWidget(self.state.viewAllPanel)
self.viewSplitter.setCollapsible(0, False)
self.viewSplitter.addWidget(self.state.replacePanel)
self.splitter = Widgets.Splitter.Splitter(Qt.Horizontal)
self.splitter.addWidget(self.panelSplitter)
self.splitter.addWidget(self.viewSplitter)
self.splitter.setCollapsible(0, False)
self.splitter.setCollapsible(1, False)
self.setCentralWidget(self.splitter)
def createActions(self):
self.fileActions = Actions.File.Actions(self)
self.fileMenu = self.menuBar().addMenu("&File")
Lib.addActions(self.fileMenu, self.fileActions.forMenu())
self.fileToolBar = self.addToolBar("File")
self.fileToolBar.setObjectName("File")
Lib.addActions(self.fileToolBar, self.fileActions.forToolbar())
self.editActions = Actions.Edit.Actions(self)
self.editMenu = self.menuBar().addMenu("&Edit")
Lib.addActions(self.editMenu, self.editActions.forMenu())
self.editToolBar = self.addToolBar("Edit")
self.editToolBar.setObjectName("Edit")
Lib.addActions(self.editToolBar, self.editActions.forToolbar())
self.insertActions = Actions.Insert.Actions(self)
self.insertMenu = self.menuBar().addMenu("Inse&rt")
Lib.addActions(self.insertMenu, self.insertActions.forMenu())
self.spellingActions = Actions.Spelling.Actions(self)
self.spellingMenu = self.menuBar().addMenu("Spe&lling")
Lib.addActions(self.spellingMenu, self.spellingActions.forMenu())
self.spellingToolBar = self.addToolBar("Spelling")
self.spellingToolBar.setObjectName("Spelling")
Lib.addActions(self.spellingToolBar, self.spellingActions.forToolbar())
self.formatActions = Actions.Format.Actions(self)
self.formatMenu = self.menuBar().addMenu("F&ormat")
Lib.addActions(self.formatMenu, self.formatActions.forMenu())
self.formatToolBar = self.addToolBar("Format")
self.formatToolBar.setObjectName("Format")
Lib.addActions(self.formatToolBar, self.formatActions.forToolbar())
self.addToolBarBreak()
# Actions created earlier
self.indexActions = Actions.Index.Actions(self) # Menu added later
self.indexToolBar = self.addToolBar("Index")
self.indexToolBar.setObjectName("Index")
Lib.addActions(self.indexToolBar, self.indexActions.forToolbar())
self.gotoActions = Actions.Goto.Actions(self)
self.gotoMenu = self.menuBar().addMenu("&Goto")
Lib.addActions(self.gotoMenu, self.gotoActions.forMenu())
# Goto toolbar is last
# These actions are created in createWidgets() because two are
# needed by the groups panel
self.entryMenu = self.menuBar().addMenu("Entr&y")
Lib.addActions(self.entryMenu, self.entryActions.forMenu())
self.entryToolBar1 = self.addToolBar("Entry Add and Copy")
self.entryToolBar1.setObjectName("Entry1")
Lib.addActions(self.entryToolBar1, self.entryActions.forToolbar1())
self.entryToolBar2 = self.addToolBar("Entry Cross-references")
self.entryToolBar2.setObjectName("Entry2")
Lib.addActions(self.entryToolBar2, self.entryActions.forToolbar2())
self.entryToolBar3 = self.addToolBar("Entry Groups")
self.entryToolBar3.setObjectName("Entry3")
Lib.addActions(self.entryToolBar3, self.entryActions.forToolbar3())
self.modifyActions = Actions.Modify.Actions(self)
self.modifyMenu = self.menuBar().addMenu("&Modify")
Lib.addActions(self.modifyMenu, self.modifyActions.forMenu())
self.modifyToolBar = self.addToolBar("Modify")
self.modifyToolBar.setObjectName("Modify")
Lib.addActions(self.modifyToolBar, self.modifyActions.forToolbar())
self.indexMenu = self.menuBar().addMenu("Inde&x")
Lib.addActions(self.indexMenu, self.indexActions.forMenu())
self.helpActions = Actions.Help.Actions(self)
self.helpMenu = self.menuBar().addMenu("&Help")
Lib.addActions(self.helpMenu, self.helpActions.forMenu())
self.addToolBarBreak()
self.gotoToolBar1 = self.addToolBar("Goto Filtered etc.")
self.gotoToolBar1.setObjectName("Goto1")
Lib.addActions(self.gotoToolBar1, self.gotoActions.forToolbar1())
self.gotoToolBar2 = self.addToolBar("Goto First, Next, etc.")
self.gotoToolBar2.setObjectName("Goto2")
Lib.addActions(self.gotoToolBar2, self.gotoActions.forToolbar2())
self.gotoToolBar4 = Widgets.AlphaBar.Bar()
self.gotoToolBar4.setWindowTitle("Goto Letter")
self.gotoToolBar4.setObjectName("Goto4")
self.addToolBar(self.gotoToolBar4)
self.gotoToolBar3 = self.addToolBar("Goto Bookmarks")
self.gotoToolBar3.setObjectName("Goto3")
Lib.addActions(self.gotoToolBar3, self.gotoActions.forToolbar3())
self.bookmarksToolButton = QToolButton()
self.bookmarksToolButton.setIcon(QIcon(":/bookmark.svg"))
self.bookmarksToolButton.setPopupMode(QToolButton.InstantPopup)
self.bookmarksToolButton.setToolTip("""\
<p><b>Goto→Bookmarks</b></p><p>Goto the bookmarked entry.""")
self.gotoToolBar3.addWidget(self.bookmarksToolButton)
for toolbar in (self.fileToolBar, self.editToolBar,
self.spellingToolBar, self.formatToolBar,
self.indexToolBar, self.entryToolBar1,
self.entryToolBar2, self.modifyToolBar,
self.gotoToolBar1, self.gotoToolBar2,
self.gotoToolBar4, self.gotoToolBar3):
toolbar.setFloatable(False)
def createConnections(self):
QShortcut(QKeySequence(Qt.CTRL + Qt.Key_T), self,
self.state.viewAllPanel.gotoLineEdit.setFocus)
self.state.viewAllPanel.view.selectedEidChanged.connect(
self.state.updateUi)
self.state.viewAllPanel.view.circledEidChanged.connect(
self.state.updateUi)
self.state.viewAllPanel.view.refreshed.connect(
self.modifyActions.updateUi)
self.state.viewFilteredPanel.view.refreshed.connect(
self.entryActions.updateUi)
self.state.viewFilteredPanel.view.refreshed.connect(
self.modifyActions.updateUi)
self.state.viewFilteredPanel.view.refreshed.connect(
self.updateFilteredGotoActions)
self.state.viewFilteredPanel.view.refreshed.connect(
self.state.replacePanel.updateUi)
self.state.model.changed.connect(self.state.updateUi)
self.state.model.edited.connect(self.state.refreshEntry)
self.state.model.can_undo.connect(self.indexActions.updateUndo)
self.state.model.can_redo.connect(self.indexActions.updateRedo)
self.state.model.group_changed.connect(
self.state.groupsPanel.updateGroups)
self.workTimer.timeout.connect(self.updateWorkTime)
self.editActions.connectEditors()
self.state.entryPanel.xrefList.itemDoubleClicked.connect(
self.gotoActions.gotoXRef)
self.state.entryPanel.xrefList.currentRowChanged.connect(
self.updateXRefGotoActions)
self.gotoToolBar4.orientationChanged.connect(
self.gotoToolBar4.setOrientation)
self.gotoToolBar4.clicked.connect(self.gotoActions.gotoPrefix)
for menu in self.menuBar().findChildren(QMenu):
for action in menu.actions():
if bool(action.toolTip()):
action.hovered.connect(
lambda action=action: self.menuHovered(action))
def menuHovered(self, action):
settings = QSettings()
if bool(
int(
settings.value(Gopt.Key.ShowMenuToolTips,
Gopt.Default.ShowMenuToolTips))):
tip = action.toolTip()
if tip:
QToolTip.showText(QCursor.pos(), tip, self)
def reportProgress(self, message):
say(message)
QApplication.processEvents()
def updateToolTips(self):
settings = QSettings()
showToolTips = bool(
int(
settings.value(Gopt.Key.ShowMainWindowToolTips,
Gopt.Default.ShowMainWindowToolTips)))
for widget, tip in self.tooltips:
widget.setToolTip(tip if showToolTips else "")
for panel in (self.state.viewAllPanel, self.state.replacePanel,
self.state.viewFilteredPanel, self.state.entryPanel,
self.state.spellPanel, self.state.groupsPanel):
panel.updateToolTips(showToolTips)
def createContextMenus(self):
for action in (self.indexActions.undoAction,
self.indexActions.redoAction,
self.gotoActions.gotoFirstAction,
self.gotoActions.gotoLastAction,
self.entryActions.addSiblingAction,
self.entryActions.addChildAction,
self.entryActions.addTopAction,
self.entryActions.copyAction,
self.entryActions.moveAction,
self.entryActions.deleteAction,
self.entryActions.addXRefAction,
self.entryActions.circleAction,
self.entryActions.addToNormalGroupAction,
self.entryActions.addToLinkedGroupAction):
self.state.viewAllPanel.view.addAction(action)
for action in (self.gotoActions.gotoFilteredAction, ):
self.state.viewFilteredPanel.view.addAction(action)
for action in (self.entryActions.addXRefAction,
self.entryActions.changeXRefAction,
self.entryActions.deleteXRefAction):
self.state.entryPanel.xrefList.addAction(action)
self.state.entryPanel.xrefList.setContextMenuPolicy(
Qt.ActionsContextMenu)
for action in (self.entryActions.addToNormalGroupAction,
self.entryActions.addToLinkedGroupAction,
self.entryActions.removeFromGroupAction,
self.entryActions.setGroupAction,
self.entryActions.editGroupsAction):
self.state.groupsPanel.groupsList.addAction(action)
self.state.groupsPanel.groupsList.setContextMenuPolicy(
Qt.ActionsContextMenu)
def __init__(self, spiderName, resumable=False, parent=None):
super(SpiderToolButton, self).__init__(parent)
self._drag_start = None
button_play = QToolButton()
button_play.setIcon(QIcon("play.png"))
self.triggered.connect(
button_play.triggered
) # clicking the outer button run the play functionality
button_play.setIconSize(QSize(32, 32))
button_resume = QToolButton()
button_resume.setEnabled(resumable)
button_resume.setIcon(QIcon("resume.png"))
button_resume.setIconSize(QSize(32, 32))
button_pause = QToolButton()
button_pause.setIcon(QIcon("pause.png"))
button_pause.setIconSize(QSize(32, 32))
self.label_spidername = QLabel(spiderName)
self.label_spidername.setStyleSheet(self.stylesheet_label_spidername)
layout = QGridLayout()
layout.addWidget(self.label_spidername, 0, 0)
layout.addWidget(button_pause, 1, 1)
layout.addWidget(button_resume, 1, 2)
layout.addWidget(button_play, 1, 3)
layout.setContentsMargins(10, 8, 10, 8)
self.setLayout(layout)
class Panel(QWidget):
def __init__(self, state, parent=None):
super().__init__(parent)
self.state = state
self.entry = None
self.saf = Saf.AUTO
self.peid = ROOT
self.createWidgets()
self.layoutWidgets()
self.createConnections()
self.showOrHideNotes()
self.showOrHideSortAs()
self.termEdit.setFocus()
def createWidgets(self):
self.helpButton = QToolButton()
self.helpButton.setIcon(QIcon(":/help.svg"))
self.helpButton.setFocusPolicy(Qt.NoFocus)
self.tooltips.append((self.helpButton, "Help on the Entry panel."))
self.addingLabel = Widgets.Label.HtmlLabel(CANCEL_ADD)
self.addingLabel.hide()
self.termLabel = QLabel("&Term")
self.termEdit = Widgets.LineEdit.HtmlLineEdit(self.state)
self.tooltips.append((self.termEdit, """\
<p><b>Term editor</b> (Alt+T)</p>
<p>The entry's term text styled (e.g., <b>bold</b>, <i>italic</i>), as
it should appear in the final index.</p>"""))
self.spellHighlighter = Widgets.SpellHighlighter.Highlighter(
self.state, self.termEdit.document())
self.termLabel.setBuddy(self.termEdit)
self.pagesLabel = QLabel("&Pages")
self.pagesEdit = Widgets.LineEdit.HtmlPagesLineEdit(self.state,
maxLines=3)
self.tooltips.append((self.pagesEdit, """\
<p><b>Pages editor</b> (Alt+P)</p>
<p>The entry's pages styled (e.g., <b>bold</b>, <i>italic</i>), as they
should appear in the final index.</p> <p>The pages are automatically
sorted, and exact duplicates are automatically removed.</p> <p>See also
<b>Index→Combine Overlapping Pages</b> and <b>Index→Renumber
Pages</b>.</p>"""))
self.pagesLabel.setBuddy(self.pagesEdit)
self.calcSortAsCheckBox = QCheckBox("&Automatically Calculate Sort As")
self.tooltips.append((self.calcSortAsCheckBox, """\
<p><b>Automatically Calculate Sort As</b> (Alt+A)</p>
<p>This checkbox controls how the Sort As text is created.</p>
<p>If checked, {} will either automatically create the sort as
text, or will present some choices from which to choose the sort as
text, depending on the term text.</p>
<p>If unchecked, the sort as text should be entered
manually.</p>""".format(QApplication.applicationName())))
self.calcSortAsCheckBox.setChecked(True)
self.sortAsHelpButton = QToolButton()
self.sortAsHelpButton.setIcon(QIcon(":/help.svg"))
self.sortAsHelpButton.setFocusPolicy(Qt.NoFocus)
self.tooltips.append(
(self.sortAsHelpButton, "Help on the Sort As text."))
self.sortAsEdit = Widgets.LineEdit.LineEdit(self.state)
self.tooltips.append((self.sortAsEdit, """\
<p><b>Sort As editor</b> (Alt+S)</p>
<p>The entry's sort as text.</p>
<p>If the <b>Automatically Calculate Sort As</b> checkbox is unchecked,
manually enter the sort as text to use for sorting the entry.</p>
<p>Main entry's are sorted using the sort as text, so it is easy to
force a non-standard ordering by entering a custom sort as text.</p>
<p>Subentries are also sorted using the sort as text, but the first word
of a subentry will be ignored for sorting purposes if it is in the
Ignore Subentry Function words list (see <b>Index→Ignore Subentry
Function words</b>) <i>and</i> the <b>Index→Options, Rules,
Ignore Subenty Function Words</b> checkbox is checked for this
index.</p>"""))
self.sortAsEdit.setEnabled(False)
self.sortAsLabel = QLabel("&Sort As")
self.sortAsLabel.setBuddy(self.sortAsEdit)
self.sortAsLabel.setEnabled(False)
self.xrefLabel = QLabel("&Cross-references")
self.xrefList = Widgets.List.HtmlListWidget(self.state, minLines=4)
self.tooltips.append((self.xrefList, """\
<p><b>Cross-references list</b> (Alt+C)</p>
<p>The list of the entry's see and see also cross-references, both
generic and to other entries.</p>
<p>To add a cross-reference to an entry, circle the <i>to</i> entry
(<b>Entry→Circle</b>), then go to the <i>from</i> entry and click
<img src=":/xref-add.svg" width={0} height={0}> or press
<b>Entry→Add Cross-reference</b> (See also the <b>Entry</b>
menu.)</p>""".format(TOOLTIP_IMAGE_SIZE)))
self.xrefLabel.setBuddy(self.xrefList)
self.notesLabel = QLabel("&Notes")
self.notesEdit = Widgets.LineEdit.MultilineHtmlEdit(self.state)
self.tooltips.append((self.notesEdit, """\
<p><b>Notes editor</b> (Alt+N)</p>
<p>The entry's notes.</p>
<p>The notes shown here are never output as part of
the index so may be freely used for any purpose.</p>
<p>If the notes facility isn't wanted, the notes can be hidden by
unchecking the <b>Index→Options, General, Show Notes</b>
checkbox.</p>"""))
self.notesLabel.setBuddy(self.notesEdit)
def layoutWidgets(self):
form = QFormLayout()
form.addRow(self.addingLabel)
hbox = QHBoxLayout()
hbox.addWidget(self.termEdit, 1)
hbox.addWidget(self.helpButton)
form.addRow(self.termLabel, hbox)
form.addRow(self.pagesLabel, self.pagesEdit)
hbox = QHBoxLayout()
hbox.addWidget(self.calcSortAsCheckBox, 1)
hbox.addWidget(self.sortAsHelpButton)
form.addRow(hbox)
form.addRow(self.sortAsLabel, self.sortAsEdit)
vbox = QVBoxLayout()
vbox.addLayout(form)
vbox.addWidget(self.xrefLabel)
vbox.addWidget(self.xrefList, 1)
vbox.addWidget(self.notesLabel)
vbox.addWidget(self.notesEdit, 1)
self.setLayout(vbox)
def createConnections(self):
self.helpButton.clicked.connect(self.help)
self.sortAsHelpButton.clicked.connect(
lambda: self.help("xix_ref_sortas.html"))
self.termEdit.textChanged.connect(self.termChanged)
self.termEdit.cursorPositionChanged.connect(self.maybeSetSuggestions)
self.termEdit.textChanged.connect(self.updateMode)
self.termEdit.lostFocus.connect(self.maybeSave)
self.termEdit.enterPressed.connect(
lambda: self.tabAndMaybeSave(self.pagesEdit))
self.pagesEdit.textChanged.connect(self.updateMode)
self.pagesEdit.lostFocus.connect(self.maybeSave)
self.pagesEdit.enterPressed.connect(
lambda: self.tabAndMaybeSave(self.calcSortAsCheckBox))
self.calcSortAsCheckBox.toggled.connect(self.calcSortAsToggled)
self.sortAsEdit.textChanged.connect(self.updateMode)
self.sortAsEdit.lostFocus.connect(self.maybeSave)
self.sortAsEdit.enterPressed.connect(
lambda: self.tabAndMaybeSave(self.xrefList))
self.notesEdit.textChanged.connect(self.updateMode)
self.notesEdit.lostFocus.connect(self.maybeSave)
def help(self, page="xix_ref_panel_entry.html"):
self.state.help(page)
def tabAndMaybeSave(self, widget):
self.maybeSave()
widget.setFocus()
def updateUi(self):
enable = self.state.mode not in {ModeKind.NO_INDEX, ModeKind.CHANGE}
self.setEnabled(enable)
if enable:
enable = (self.state.mode in {ModeKind.ADD, ModeKind.EDIT}
or not self.termEdit.isEmpty())
for widget in (self.termEdit, self.pagesEdit,
self.calcSortAsCheckBox, self.xrefList,
self.notesEdit):
widget.setEnabled(enable)
self.sortAsEdit.setEnabled(
enable and not self.calcSortAsCheckBox.isChecked())
if self.state.mode is ModeKind.ADD:
self.state.window.modeLabel.setText(
"<font color=green>Adding</font>")
def updateDisplayFonts(self):
for widget in (self.termEdit, self.sortAsEdit, self.pagesEdit,
self.notesEdit, self.xrefList):
widget.updateDisplayFonts()
def populateEditors(self, editors):
editors |= {
self.termEdit, self.sortAsEdit, self.pagesEdit, self.notesEdit
}
def maybeSave(self):
if self.hasChanged():
if not bool(self.sortAsEdit.toPlainText().strip()):
sortas = self.state.model.sortBy(self.termEdit.toHtml(),
self.saf, self.peid
is not ROOT)
self.sortAsEdit.setPlainText(sortas)
self.state.save()
def hasChanged(self):
term = self.termEdit.toHtml()
sortas = self.sortAsEdit.toPlainText().strip()
pages = self.pagesEdit.toHtml()
notes = self.notesEdit.toHtml()
if self.entry is None:
return bool(term or sortas or pages or notes)
return (self.entry.term != term or self.entry.sortas != sortas
or self.entry.pages != pages or self.entry.notes != notes
or self.entry.saf != self.saf)
def updateMode(self):
if (self.state.mode not in {
ModeKind.NO_INDEX, ModeKind.ADD, ModeKind.EDIT, ModeKind.CHANGE
} and self.hasChanged()):
self.state.setMode(ModeKind.EDIT)
def clearForm(self):
self.state.spellPanel.clearSuggestions()
self.state.groupsPanel.clear()
positions = Positions(self.termEdit.textCursor().position(),
self.sortAsEdit.textCursor().position(),
self.pagesEdit.textCursor().position(),
self.notesEdit.textCursor().position())
self.termEdit.clear()
self.calcSortAsCheckBox.setChecked(True)
self.sortAsEdit.clear()
self.pagesEdit.clear()
self.xrefList.clear()
self.notesEdit.clear()
return positions
def setEntry(self, entry):
positions = self.clearForm()
self.entry = entry
if entry is not None:
self.termEdit.setHtml(entry.term, positions.term)
self.saf = entry.saf or Saf.AUTO
self.calcSortAsCheckBox.setChecked(self.saf != Saf.CUSTOM)
self.sortAsEdit.setPlainText(entry.sortas, positions.sortas)
self.pagesEdit.setHtml(entry.pages, positions.pages)
self.notesEdit.setHtml(entry.notes, positions.notes)
for xref in list(self.state.model.xrefs(entry.eid)):
kind = "See" if xref.kind is XrefKind.SEE else "See also"
term = Lib.elidePatchHtml(self.state.model.termPath(
xref.to_eid),
self.state,
maxlen=None)
item = QListWidgetItem("{} <i>{}</i> {}".format(
XREF_INDICATOR, kind, term))
item.setData(Qt.UserRole, xref)
self.xrefList.addItem(item)
for xref in list(self.state.model.generic_xrefs(entry.eid)):
kind = ("See (generic)" if xref.kind is XrefKind.SEE_GENERIC
else "See also (generic)")
item = QListWidgetItem("{} <i>{}</i> {}".format(
XREF_INDICATOR, kind, xref.term))
item.setData(Qt.UserRole, xref)
self.xrefList.addItem(item)
if self.xrefList.count():
self.xrefList.setCurrentRow(0)
self.state.updateGotoEids(entry.eid)
self.state.groupsPanel.updateGroups()
self.state.updateNavigationStatus()
self.state.setMode(ModeKind.VIEW)
@property
def unknownWords(self):
return self.spellHighlighter.unknownWords
def termChanged(self):
if self.addingLabel.isVisible():
self.addingLabel.setText(CANCEL_ADD)
text = self.termEdit.toPlainText()
if bool(self.state.model):
while text:
eid = self.state.model.firstForPrefix(text)
if eid is not None:
term = Lib.elidePatchHtml(self.state.model.term(eid),
self.state)
self.addingLabel.setText(CANCEL_ADD +
" and goto “{}”".format(term))
break
text = text[:-1]
self.maybeSetSuggestions()
def maybeSetSuggestions(self):
word, _ = self.termEdit.wordAndPosition()
if word:
if self.termEdit.hasFocus():
replacement = self.state.model.autoReplacementFor(word)
if replacement is not None:
self.termEdit.replaceWord(replacement)
return
self.state.spellPanel.populateSuggestions(word)
else:
self.state.spellPanel.clearSuggestions()
def rememberWord(self):
word = self.findNearestUnknownWord()
if word:
Spell.add(word, self.state.language.value)
self.state.model.addSpellWord(word)
self.spellHighlighter.rehighlight()
def ignoreWord(self):
word = self.findNearestUnknownWord()
if word:
self.spellHighlighter.wordsToIgnore.add(word)
self.spellHighlighter.rehighlight()
def findNearestUnknownWord(self):
pos = self.termEdit.textCursor().position()
where = -1
unknownWord = None
unknownWords = sorted(self.unknownWords)
for i, word in unknownWords:
if i > where and i <= pos:
where = i
unknownWord = word
if i > pos:
break
if unknownWord is None and unknownWords:
unknownWord = unknownWords[-1][1]
return unknownWord
def completeWithSuggested(self):
index = self.state.spellPanel.currentRow()
self.complete(index)
def complete(self, i):
item = self.state.spellPanel.item(i)
if item:
word = self.state.spellPanel.item(i).text()
self.completeWord(word)
def completeWord(self, word):
word = COMPLETE_WORD_RX.sub("", word)
if word:
self.termEdit.replaceWord(word)
def showOrHideNotes(self):
settings = QSettings()
visible = bool(
int(settings.value(Gopt.Key.ShowNotes, Gopt.Default.ShowNotes)))
self.notesLabel.setVisible(visible)
self.notesEdit.setVisible(visible)
def showOrHideSortAs(self):
settings = QSettings()
alwaysShowSortAs = bool(
int(
settings.value(Gopt.Key.AlwaysShowSortAs,
Gopt.Default.AlwaysShowSortAs)))
editable = not self.calcSortAsCheckBox.isChecked()
visible = alwaysShowSortAs or editable
for widget in (self.sortAsLabel, self.sortAsEdit):
widget.setVisible(visible)
widget.setEnabled(editable)
def calcSortAsToggled(self):
self.showOrHideSortAs()
self.updateMode()
if self.calcSortAsCheckBox.isChecked():
saf = self.saf if self.saf != Saf.CUSTOM else Saf.AUTO
self.state.calculateSortAs(saf, force=True)
else:
self.saf = Saf.CUSTOM
def __init__(self, spiderName, resumable=False,parent=None):
super(SpiderToolButton, self).__init__(parent)
self._drag_start = None
button_play = QToolButton()
button_play.setIcon(QIcon("play.png"))
self.triggered.connect(button_play.triggered) # clicking the outer button run the play functionality
button_play.setIconSize(QSize(32, 32))
button_resume = QToolButton()
button_resume.setEnabled(resumable)
button_resume.setIcon(QIcon("resume.png"))
button_resume.setIconSize(QSize(32, 32))
button_pause = QToolButton()
button_pause.setIcon(QIcon("pause.png"))
button_pause.setIconSize(QSize(32, 32))
self.label_spidername = QLabel(spiderName)
self.label_spidername.setStyleSheet(self.stylesheet_label_spidername)
layout = QGridLayout()
layout.addWidget(self.label_spidername, 0, 0)
layout.addWidget(button_pause, 1,1)
layout.addWidget(button_resume, 1, 2)
layout.addWidget(button_play, 1, 3)
layout.setContentsMargins(10, 8, 10, 8)
self.setLayout(layout)
def CreateFlatButton(action):
"""
Create a custom flat button and style
it so that it will look good on all platforms.
"""
toolButton = QToolButton()
toolButton.setIcon(action.icon())
toolButton.setText(action.text())
toolButton.setAutoRaise(True)
toolButton.setIconSize(QSize(32, 32))
toolButton.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
if sys.platform.startswith('darwin'):
# Bug for Mac: QToolButtons do not react to setAutoRaise so
# can't be made flat when they are not used inside a toolbar.
# Setting a custom style sheet with border to none fixes this.
# But then it looses all its highlight and pressed visual cues
# so some extra styling needs to be done to provide some nice
# visual feedback on hover and pressed states.
toolButton.setStyleSheet(
"QToolButton {"
"border: none;"
"} "
"QToolButton:hover {"
"background-color: qradialgradient(cx: 0.5, cy: 0.5,"
"fx: 0.5, fy: 0.5,"
"radius: 0.5, "
"stop: 0 rgba(255, 255, 255, 100), "
"stop: 1 rgba(0, 0, 0, 0));"
"}"
"QToolButton:pressed {"
"background-color: qradialgradient(cx: 0.5, cy: 0.5,"
"fx: 0.5, fy: 0.5,"
"radius: 0.5, "
"stop: 0 rgba(255, 255, 255, 200), "
"stop: 1 rgba(0, 0, 0, 0));"
"}")
font = QFont()
font.setPixelSize(10)
toolButton.setFont(font)
# Connect the clicked signal to the action trigger
def pushed():
toolButton.action.triggered.emit()
setattr(toolButton, "pushed", pushed)
toolButton.clicked.connect(toolButton.pushed)
setattr(toolButton, "action", action)
return toolButton
def createWidgets(self):
settings = QSettings()
self.searchLabel = QLabel("Search For")
self.searchLineEdit = QLineEdit()
self.tooltips.append((self.searchLineEdit, """\
<p><b>Search For editor</b></p>
<p>The text or regular expression to search for.</p>"""))
self.searchLabel.setBuddy(self.searchLineEdit)
self.replaceLabel = QLabel("Replace With")
self.replaceLineEdit = QLineEdit()
self.tooltips.append((self.replaceLineEdit, """\
<p><b>Replace With editor</b></p>
<p>The replacement text (which may include backreferences, \\1, \\2,
etc., if a regular expression search is being made).</p>"""))
self.replaceLabel.setBuddy(self.replaceLineEdit)
self.allEntriesRadioButton = QRadioButton("All Entries")
self.allEntriesRadioButton.setChecked(
bool(int(settings.value("RP/All", 1))))
self.tooltips.append((self.allEntriesRadioButton, """\
<p><b>All Entries</b></p>
<p>If checked, the search will consider every entry in the index.</p>"""))
self.filteredEntriesRadioButton = QRadioButton("Filtered Entries")
self.filteredEntriesRadioButton.setChecked(
bool(int(settings.value("RP/Filtered", 0))))
self.tooltips.append((self.filteredEntriesRadioButton, """\
<p><b>Filtered Entries</b></p>
<p>If checked, the search will consider only those entries that are in
the current filtered view.</p>"""))
self.considerLabel = QLabel("Consider")
self.scopeGroup = QButtonGroup()
self.scopeGroup.addButton(self.allEntriesRadioButton)
self.scopeGroup.addButton(self.filteredEntriesRadioButton)
self.literalRadioButton = QRadioButton("Literal")
self.literalRadioButton.setChecked(
bool(int(settings.value("RP/Literal", 1))))
self.tooltips.append((self.literalRadioButton, """<p><b>Literal</b></p>
<p>If checked, the <b>Search For</b> text will be searched for
literally.</p>"""))
self.regexRadioButton = QRadioButton("Regex")
self.regexRadioButton.setChecked(
bool(int(settings.value("RP/Regex", 0))))
self.tooltips.append((self.regexRadioButton, """<p><b>Regex</b></p>
<p>If checked, the <b>Search For</b> text will be searched for
as a regular expression pattern.</p>"""))
self.matchAsGroup = QButtonGroup()
self.matchAsGroup.addButton(self.literalRadioButton)
self.matchAsGroup.addButton(self.regexRadioButton)
self.ignoreCaseCheckBox = QCheckBox("Ignore Case")
self.ignoreCaseCheckBox.setChecked(
bool(int(settings.value("RP/ICase", 0))))
self.tooltips.append((self.ignoreCaseCheckBox, """\
<p><b>Ignore Case</b></p>
<p>If checked, the <b>Search For</b> text will be searched for
case-insensitively.</p>"""))
self.wholeWordsCheckBox = QCheckBox("Whole Words")
self.wholeWordsCheckBox.setChecked(
bool(int(settings.value("RP/WW", 0))))
self.tooltips.append((self.wholeWordsCheckBox, """\
<p><b>Whole Words</b></p>
<p>If checked—and when <b>Literal</b> is checked—the
<b>Search For</b> text will be matched as whole words.</p>
<p>For example, “habit” will not match “habitat” when whole words is
checked.</p>
<p>(For regular expressions use \\b before and after each word to get
whole word matches.)</p>"""))
self.replaceInLabel = QLabel("Look In")
self.replaceInTermsCheckBox = QCheckBox("Terms")
self.replaceInTermsCheckBox.setChecked(
bool(int(settings.value("RP/Terms", 1))))
self.tooltips.append((self.replaceInTermsCheckBox, """\
<p><b>Terms</b></p>
<p>If checked, the search will look in term texts.</p>"""))
self.replaceInPagesCheckBox = QCheckBox("Pages")
self.replaceInPagesCheckBox.setChecked(
bool(int(settings.value("RP/Pages", 0))))
self.tooltips.append((self.replaceInPagesCheckBox, """\
<p><b>Pages</b></p>
<p>If checked, the search will look in pages texts.</p>"""))
self.replaceInNotesCheckBox = QCheckBox("Notes")
self.replaceInNotesCheckBox.setChecked(
bool(int(settings.value("RP/Notes", 0))))
self.tooltips.append((self.replaceInNotesCheckBox, """\
<p><b>Notes</b></p>
<p>If checked, the search will look in notes texts.</p>"""))
self.startButton = QPushButton(QIcon(":/edit-find.svg"),
"Start Search")
self.tooltips.append((self.startButton, """<p><b>Start Search</b></p>
<p>Start the search from the first entry in the index or the first entry
in the filtered view's entries.</p>"""))
self.replaceButton = QPushButton(QIcon(":/edit-find-replace.svg"),
"Replace")
self.tooltips.append((self.replaceButton, """<p><b>Replace</b></p>
<p>Replace the highlighted text with the <b>Replace With</b> text (using
backreferences if they are in the replacement text and a <b>Regex</b>
search is underway), and then try to find the next matching text.</p>"""))
self.skipButton = QPushButton(QIcon(":/skip.svg"), "S&kip")
self.tooltips.append((self.skipButton, """<p><b>Skip</b></p>
<p>Skip the highlighted text and try to find the next matching
text.</p>"""))
self.stopButton = QPushButton(QIcon(":/process-stop.svg"),
"Stop Search")
self.tooltips.append((self.stopButton, """<p><b>Stop Search</b></p>
<p>Stop the current search. This allows the search options to be
changed.</p>"""))
self.closeButton = QToolButton()
self.closeButton.setIcon(QIcon(":/hide.svg"))
self.closeButton.setFocusPolicy(Qt.NoFocus)
self.tooltips.append((self.closeButton, """<p><b>Hide</b></p>
<p>Hide the Search and Replace panel.</p>
<p>Press <b>Ctrl+H</b> or click <img src=":/edit-find-replace.svg"
width={0} height={0}> or click <b>Edit→Search and Replace</b> to show it
again.</p>""".format(TOOLTIP_IMAGE_SIZE)))
self.helpButton = QToolButton()
self.helpButton.setIcon(QIcon(":/help.svg"))
self.helpButton.setFocusPolicy(Qt.NoFocus)
self.tooltips.append(
(self.helpButton, "Help on the Search and Replace panel."))
def setupUi(self):
scene = QGraphicsScene(self)
self.view = QGraphicsView(scene, self)
self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setVisible(True)
self.view.setInteractive(True)
self.createPixmapIcon()
self.mapWidget = MapWidget(self.mapManager)
scene.addItem(self.mapWidget)
self.mapWidget.setCenter(QGeoCoordinate(-8.1, -34.95))
self.mapWidget.setZoomLevel(5)
#...
self.slider = QSlider(Qt.Vertical, self)
self.slider.setTickInterval(1)
self.slider.setTickPosition(QSlider.TicksBothSides)
self.slider.setMaximum(self.mapManager.maximumZoomLevel())
self.slider.setMinimum(self.mapManager.minimumZoomLevel())
self.slider.valueChanged[int].connect(self.sliderValueChanged)
self.mapWidget.zoomLevelChanged[float].connect(self.mapZoomLevelChanged)
mapControlLayout = QVBoxLayout()
self.mapWidget.mapTypeChanged.connect(self.mapTypeChanged)
for mapType in self.mapWidget.supportedMapTypes():
radio = QRadioButton(self)
if mapType == QGraphicsGeoMap.StreetMap:
radio.setText('Street')
elif mapType == QGraphicsGeoMap.SatelliteMapDay:
radio.setText('Sattelite')
elif mapType == QGraphicsGeoMap.SatelliteMapNight:
radio.setText('Sattelite - Night')
elif mapType == QGraphicsGeoMap.TerrainMap:
radio.setText('Terrain')
if mapType == self.mapWidget.mapType():
radio.setChecked(True)
radio.toggled[bool].connect(self.mapTypeToggled)
self.mapControlButtons.append(radio)
self.mapControlTypes.append(mapType)
mapControlLayout.addWidget(radio)
self.latitudeEdit = QLineEdit()
self.longitudeEdit = QLineEdit()
formLayout = QFormLayout()
formLayout.addRow('Latitude', self.latitudeEdit)
formLayout.addRow('Longitude', self.longitudeEdit)
self.captureCoordsButton = QToolButton()
self.captureCoordsButton.setText('Capture coordinates')
self.captureCoordsButton.setCheckable(True)
self.captureCoordsButton.toggled[bool].connect(
self.mapWidget.setMouseClickCoordQuery)
self.mapWidget.coordQueryResult.connect(self.updateCoords)
self.setCoordsButton = QPushButton()
self.setCoordsButton.setText('Set coordinates')
self.setCoordsButton.clicked.connect(self.setCoordsClicked)
buttonLayout = QHBoxLayout()
buttonLayout.addWidget(self.captureCoordsButton)
buttonLayout.addWidget(self.setCoordsButton)
coordControlLayout = QVBoxLayout()
coordControlLayout.addLayout(formLayout)
coordControlLayout.addLayout(buttonLayout)
widget = QWidget(self)
layout = QGridLayout()
layout.setRowStretch(0, 1)
layout.setRowStretch(1, 0)
topLayout = QGridLayout()
bottomLayout = QGridLayout()
topLayout.setColumnStretch(0, 0)
topLayout.setColumnStretch(1, 1)
bottomLayout.setColumnStretch(0, 0)
bottomLayout.setColumnStretch(1, 1)
topLayout.addWidget(self.slider, 0, 0)
topLayout.addWidget(self.view, 0, 1)
bottomLayout.addLayout(mapControlLayout, 0, 0)
bottomLayout.addLayout(coordControlLayout, 0, 1)
layout.addLayout(topLayout, 0, 0)
layout.addLayout(bottomLayout, 1, 0)
self.layout = layout
widget.setLayout(layout)
self.setCentralWidget(widget)
self.view.setContextMenuPolicy(Qt.CustomContextMenu)
self.view.customContextMenuRequested.connect(self.customContextMenuRequest)
def createActions(self):
self.fileActions = Actions.File.Actions(self)
self.fileMenu = self.menuBar().addMenu("&File")
Lib.addActions(self.fileMenu, self.fileActions.forMenu())
self.fileToolBar = self.addToolBar("File")
self.fileToolBar.setObjectName("File")
Lib.addActions(self.fileToolBar, self.fileActions.forToolbar())
self.editActions = Actions.Edit.Actions(self)
self.editMenu = self.menuBar().addMenu("&Edit")
Lib.addActions(self.editMenu, self.editActions.forMenu())
self.editToolBar = self.addToolBar("Edit")
self.editToolBar.setObjectName("Edit")
Lib.addActions(self.editToolBar, self.editActions.forToolbar())
self.insertActions = Actions.Insert.Actions(self)
self.insertMenu = self.menuBar().addMenu("Inse&rt")
Lib.addActions(self.insertMenu, self.insertActions.forMenu())
self.spellingActions = Actions.Spelling.Actions(self)
self.spellingMenu = self.menuBar().addMenu("Spe&lling")
Lib.addActions(self.spellingMenu, self.spellingActions.forMenu())
self.spellingToolBar = self.addToolBar("Spelling")
self.spellingToolBar.setObjectName("Spelling")
Lib.addActions(self.spellingToolBar, self.spellingActions.forToolbar())
self.formatActions = Actions.Format.Actions(self)
self.formatMenu = self.menuBar().addMenu("F&ormat")
Lib.addActions(self.formatMenu, self.formatActions.forMenu())
self.formatToolBar = self.addToolBar("Format")
self.formatToolBar.setObjectName("Format")
Lib.addActions(self.formatToolBar, self.formatActions.forToolbar())
self.addToolBarBreak()
# Actions created earlier
self.indexActions = Actions.Index.Actions(self) # Menu added later
self.indexToolBar = self.addToolBar("Index")
self.indexToolBar.setObjectName("Index")
Lib.addActions(self.indexToolBar, self.indexActions.forToolbar())
self.gotoActions = Actions.Goto.Actions(self)
self.gotoMenu = self.menuBar().addMenu("&Goto")
Lib.addActions(self.gotoMenu, self.gotoActions.forMenu())
# Goto toolbar is last
# These actions are created in createWidgets() because two are
# needed by the groups panel
self.entryMenu = self.menuBar().addMenu("Entr&y")
Lib.addActions(self.entryMenu, self.entryActions.forMenu())
self.entryToolBar1 = self.addToolBar("Entry Add and Copy")
self.entryToolBar1.setObjectName("Entry1")
Lib.addActions(self.entryToolBar1, self.entryActions.forToolbar1())
self.entryToolBar2 = self.addToolBar("Entry Cross-references")
self.entryToolBar2.setObjectName("Entry2")
Lib.addActions(self.entryToolBar2, self.entryActions.forToolbar2())
self.entryToolBar3 = self.addToolBar("Entry Groups")
self.entryToolBar3.setObjectName("Entry3")
Lib.addActions(self.entryToolBar3, self.entryActions.forToolbar3())
self.modifyActions = Actions.Modify.Actions(self)
self.modifyMenu = self.menuBar().addMenu("&Modify")
Lib.addActions(self.modifyMenu, self.modifyActions.forMenu())
self.modifyToolBar = self.addToolBar("Modify")
self.modifyToolBar.setObjectName("Modify")
Lib.addActions(self.modifyToolBar, self.modifyActions.forToolbar())
self.indexMenu = self.menuBar().addMenu("Inde&x")
Lib.addActions(self.indexMenu, self.indexActions.forMenu())
self.helpActions = Actions.Help.Actions(self)
self.helpMenu = self.menuBar().addMenu("&Help")
Lib.addActions(self.helpMenu, self.helpActions.forMenu())
self.addToolBarBreak()
self.gotoToolBar1 = self.addToolBar("Goto Filtered etc.")
self.gotoToolBar1.setObjectName("Goto1")
Lib.addActions(self.gotoToolBar1, self.gotoActions.forToolbar1())
self.gotoToolBar2 = self.addToolBar("Goto First, Next, etc.")
self.gotoToolBar2.setObjectName("Goto2")
Lib.addActions(self.gotoToolBar2, self.gotoActions.forToolbar2())
self.gotoToolBar4 = Widgets.AlphaBar.Bar()
self.gotoToolBar4.setWindowTitle("Goto Letter")
self.gotoToolBar4.setObjectName("Goto4")
self.addToolBar(self.gotoToolBar4)
self.gotoToolBar3 = self.addToolBar("Goto Bookmarks")
self.gotoToolBar3.setObjectName("Goto3")
Lib.addActions(self.gotoToolBar3, self.gotoActions.forToolbar3())
self.bookmarksToolButton = QToolButton()
self.bookmarksToolButton.setIcon(QIcon(":/bookmark.svg"))
self.bookmarksToolButton.setPopupMode(QToolButton.InstantPopup)
self.bookmarksToolButton.setToolTip("""\
<p><b>Goto→Bookmarks</b></p><p>Goto the bookmarked entry.""")
self.gotoToolBar3.addWidget(self.bookmarksToolButton)
for toolbar in (self.fileToolBar, self.editToolBar,
self.spellingToolBar, self.formatToolBar,
self.indexToolBar, self.entryToolBar1,
self.entryToolBar2, self.modifyToolBar,
self.gotoToolBar1, self.gotoToolBar2,
self.gotoToolBar4, self.gotoToolBar3):
toolbar.setFloatable(False)
