def __init__(self):
super(ExtendedTabWidget, self).__init__()
self._tab_bar = None
self._stack = QStackedWidget()
self._main_layout = QBoxLayout(QBoxLayout.LeftToRight)
self._main_layout.setContentsMargins(0, 0, 0, 0)
self._main_layout.addWidget(self._stack)
self.setLayout(self._main_layout)
def __init__(self, *, dock_area: 'DockAreaWidget' = None,
dock_widget: 'DockWidget' = None,
dock_manager: 'DockManager' = None):
'''
Parameters
----------
dock_manager : DockManager
dock_area : DockAreaWidget
Create floating widget with the given dock area
'''
if dock_manager is None:
if dock_area is not None:
dock_manager = dock_area.dock_manager()
elif dock_widget is not None:
dock_manager = dock_widget.dock_manager()
if dock_manager is None:
raise ValueError('Must pass in either dock_area, dock_widget, or dock_manager')
super().__init__(dock_manager)
self.d = FloatingDockContainerPrivate(self)
self.d.dock_manager = dock_manager
dock_container = DockContainerWidget(dock_manager, self)
self.d.dock_container = dock_container
dock_container.destroyed.connect(self._destroyed)
dock_container.dock_areas_added.connect(self.on_dock_areas_added_or_removed)
dock_container.dock_areas_removed.connect(self.on_dock_areas_added_or_removed)
if LINUX:
self.d.title_bar = FloatingWidgetTitleBar(self)
self.setWindowFlags(super().windowFlags() | Qt.Tool)
self.setWidget(self.d.dock_container)
self.setFloating(True)
self.setFeatures(QDockWidget.AllDockWidgetFeatures)
self.setTitleBarWidget(self.d.title_bar)
self.d.title_bar.close_requested.connect(self.close)
else:
self.setWindowFlags(Qt.Window | Qt.WindowMaximizeButtonHint | Qt.WindowCloseButtonHint)
layout = QBoxLayout(QBoxLayout.TopToBottom)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
self.setLayout(layout)
layout.addWidget(dock_container)
dock_manager.register_floating_widget(self)
# We install an event filter to detect mouse release events because we
# do not receive mouse release event if the floating widget is behind
# the drop overlay cross
qapp = QApplication.instance()
qapp.installEventFilter(self)
if dock_area is not None:
dock_container.add_dock_area(dock_area)
elif dock_widget is not None:
dock_container.add_dock_widget(
DockWidgetArea.center, dock_widget)
if (dock_area or dock_widget) and LINUX:
self.d.title_bar.enable_close_button(self.is_closable())
def __init__(self, parent=None, title=None):
super(AbstractInputGroupBox, self).__init__(parent)
# setup main layout
QBoxLayout(QBoxLayout.TopToBottom, self)
self.layout().setAlignment(Qt.AlignTop)
# create separator
self.separator = AbstractHLine(self)
self.separator.setStyleSheet("""
background-color: rgba{rgba_text};
margin: 30px;
""".format(rgba_text=repr(iColor["rgba_text"])))
self.layout().addWidget(self.separator)
# set up default attrs
if title:
self.setTitle(title)
self._rgba_border = iColor["rgba_outline"]
self._padding = AbstractInputGroupBox.PADDING
self._rgba_background = iColor["rgba_gray_0"]
self._rgba_text = iColor["rgba_text"]
# setup display styles
self.display_background = True
self.updateStyleSheet()
font_size = getFontSize(QApplication)
self.layout().setContentsMargins(self.padding * 3, font_size * 2,
self.padding * 3, font_size)
self.layout().setSpacing(font_size)
self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
def __init__(self, parent: 'DockAreaWidget'):
'''
Default Constructor
Parameters
----------
parent : DockAreaWidget
'''
super().__init__(parent)
self.d = DockAreaTabBarPrivate(self)
self.d.dock_area = parent
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Ignored)
self.setFrameStyle(QFrame.NoFrame)
self.setWidgetResizable(True)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.d.tabs_container_widget = QWidget()
self.d.tabs_container_widget.setObjectName("tabsContainerWidget")
self.setWidget(self.d.tabs_container_widget)
self.d.tabs_layout = QBoxLayout(QBoxLayout.LeftToRight)
self.d.tabs_layout.setContentsMargins(0, 0, 0, 0)
self.d.tabs_layout.setSpacing(0)
self.d.tabs_layout.addStretch(1)
self.d.tabs_container_widget.setLayout(self.d.tabs_layout)
def __init__(self, parent=None, standalone=False):
super(JogIncrementWidget, self).__init__(parent)
self._container = hBox = QBoxLayout(QBoxLayout.LeftToRight, self)
hBox.setContentsMargins(0, 0, 0, 0)
self._ledDiameter = 15
self._ledColor = QColor('green')
self._alignment = Qt.AlignTop | Qt.AlignRight
# This prevents doing unneeded initialization
# when QtDesginer loads the plugin.
if parent is None and not standalone:
return
increments = INFO.getIncrements()
for increment in increments:
button = LEDButton()
button.setCheckable(True)
button.setAutoExclusive(True)
button.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
button.setMinimumSize(50, 42)
if increment != 0:
raw_increment = increment.strip()
# print '[', raw_increment, ']'
button.setText(raw_increment)
button.clicked.connect(self.setJogIncrement)
hBox.addWidget(button)
self.placeLed()
def __init__(self, title: str, parent: QWidget = None):
'''
This constructor creates a dock widget with the given title. The title
is the text that is shown in the window title when the dock widget is
floating and it is the title that is shown in the titlebar or the tab
of this dock widget if it is tabified. The object name of the dock
widget is also set to the title. The object name is required by the
dock manager to properly save and restore the state of the dock widget.
That means, the title needs to be unique. If your title is not unique
or if you would like to change the title during runtime, you need to
set a unique object name explicitely by calling setObjectName() after
construction. Use the layoutFlags to configure the layout of the dock
widget.
Parameters
----------
title : str
parent : QWidget
'''
super().__init__(parent)
self.d = DockWidgetPrivate(self)
self.d.layout = QBoxLayout(QBoxLayout.TopToBottom)
self.d.layout.setContentsMargins(0, 0, 0, 0)
self.d.layout.setSpacing(0)
self.setLayout(self.d.layout)
self.setWindowTitle(title)
self.setObjectName(title)
from .dock_widget_tab import DockWidgetTab
self.d.tab_widget = DockWidgetTab(dock_widget=self, parent=None) # TODO: parent?
self.d.toggle_view_action = QAction(title, None)
self.d.toggle_view_action.setCheckable(True)
self.d.toggle_view_action.triggered.connect(self.toggle_view)
self.set_toolbar_floating_style(False)
def __init__(self):
super(ExtendedTabBar, self).__init__()
self._tab_bar = _NoMinimumWidthTabBar()
self._left_toolbar = QToolBar()
self._floating_toolbar = QToolBar()
self._right_toolbar = QToolBar()
# Setup the layout.
self._main_layout = QBoxLayout(QBoxLayout.LeftToRight)
self._main_layout.setContentsMargins(0, 0, 0, 0)
self._main_layout.setSpacing(0)
self._main_layout.addWidget(self._left_toolbar)
self._main_layout.addWidget(self._tab_bar)
self._main_layout.addWidget(self._floating_toolbar)
self._main_layout.addStretch()
self._main_layout.addWidget(self._right_toolbar)
self.setLayout(self._main_layout)
def buttonsLayout(self, buttonElementTuple, r2l=False, translation=True):
buttonsLayout = QBoxLayout(
QBoxLayout.RightToLeft if r2l else QBoxLayout.LeftToRight)
buttonsLayout.setSpacing(5)
for label, action in buttonElementTuple:
buttonLabel = config.thisTranslation[
label] if translation else label
button = QPushButton(buttonLabel)
button.clicked.connect(action)
buttonsLayout.addWidget(button)
return buttonsLayout
def __init__(self, dock_manager: 'DockManager',
parent: 'DockContainerWidget'):
'''
Default Constructor
Parameters
----------
dock_manager : DockManager
parent : DockContainerWidget
'''
super().__init__(parent)
self.d = DockAreaWidgetPrivate(self)
self.d.dock_manager = dock_manager
self.d.layout = QBoxLayout(QBoxLayout.TopToBottom)
self.d.layout.setContentsMargins(0, 0, 0, 0)
self.d.layout.setSpacing(0)
self.setLayout(self.d.layout)
self.d.create_title_bar()
self.d.contents_layout = DockAreaLayout(self.d.layout)
def __init__(self, parent: 'DockAreaWidget'):
'''
Default Constructor
Parameters
----------
parent : DockAreaWidget
'''
super().__init__(parent)
self.d = DockAreaTitleBarPrivate(self)
self.d.dock_area = parent
self.setObjectName("dockAreaTitleBar")
self.d.top_layout = QBoxLayout(QBoxLayout.LeftToRight)
self.d.top_layout.setContentsMargins(0, 0, 0, 0)
self.d.top_layout.setSpacing(0)
self.setLayout(self.d.top_layout)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.d.create_tab_bar()
self.d.create_buttons()
def __init__(self,
parent=None,
delegate=None,
direction=QBoxLayout.LeftToRight):
super(ColorHeaderWidget, self).__init__(parent)
self.setWidgetResizable(True)
# setup default attrs
if not delegate:
delegate = parent
self._delegate = delegate
self._header_item_type = ColorHeaderWidgetItem
# setup GUI
self._widget_dict = {}
self.main_widget = QFrame(self)
self.setWidget(self.main_widget)
self.main_layout = QBoxLayout(direction, self.main_widget)
# set signals
self.setHeaderItemChanged(self.updateColorArg)
def __init__(self,
parent=None,
name="None",
note="None",
direction=Qt.Horizontal):
super(AbstractInputGroupFrame, self).__init__(parent)
QBoxLayout(QBoxLayout.LeftToRight, self)
# default attrs
self._separator_length = -1
self._separator_width = 3
self._is_header_shown = True
# setup layout
from cgwidgets.widgets.AbstractWidgets.AbstractInputWidgets import AbstractLabelInputWidget
self._label = AbstractLabelInputWidget(self)
self._label.setUserFinishedEditingEvent(self.headerTextChanged)
self._label.setText(name)
# set up display
self.setToolTip(note)
self.setupStyleSheet()
self.setDirection(direction)
def setupUI(self):
mainLayout = QGridLayout()
commandBox = QVBoxLayout()
commandBox.setSpacing(3)
commandBar = QWidget()
commandLayout1 = QBoxLayout(QBoxLayout.LeftToRight)
commandLayout1.setSpacing(5)
self.searchLineEdit = QLineEdit()
self.searchLineEdit.setClearButtonEnabled(True)
self.searchLineEdit.setToolTip(
config.thisTranslation["enter_command_here"])
self.searchLineEdit.returnPressed.connect(self.searchLineEntered)
self.searchLineEdit.setFixedWidth(300)
commandLayout1.addWidget(self.searchLineEdit)
enterButton = QPushButton(config.thisTranslation["enter"])
enterButton.setFixedWidth(100)
enterButton.clicked.connect(self.searchLineEntered)
commandLayout1.addWidget(enterButton)
commandLayout1.addStretch()
commandBox.addLayout(commandLayout1)
commandLayout2 = QBoxLayout(QBoxLayout.LeftToRight)
commandLayout2.setSpacing(5)
keys = [
'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', ':', '-', ',',
'.', ' ', '<', 'X'
]
for key in keys:
button = QPushButton(key)
button.setMaximumWidth(30)
button.clicked.connect(partial(self.keyEntryAction, key))
commandLayout2.addWidget(button)
commandLayout2.addStretch()
commandBox.addLayout(commandLayout2)
if config.isTtsInstalled:
ttsLayout = QBoxLayout(QBoxLayout.LeftToRight)
ttsLayout.setSpacing(5)
self.languageCombo = QComboBox()
ttsLayout.addWidget(self.languageCombo)
if config.espeak:
languages = TtsLanguages().isoLang2epeakLang
else:
languages = TtsLanguages().isoLang2qlocaleLang
self.languageCodes = list(languages.keys())
for code in self.languageCodes:
self.languageCombo.addItem(languages[code][1])
# Check if selected tts engine has the language user specify.
if not (config.ttsDefaultLangauge in self.languageCodes):
config.ttsDefaultLangauge = "en"
# Set initial item
initialIndex = self.languageCodes.index(config.ttsDefaultLangauge)
self.languageCombo.setCurrentIndex(initialIndex)
# setting tts default language here is confusing; better place in menu
#setDefaultButton = QPushButton(config.thisTranslation["setDefault"])
#setDefaultButton.setFixedWidth(130)
#setDefaultButton.clicked.connect(self.setTtsDefaultLanguage)
#ttsLayout.addWidget(setDefaultButton)
speakButton = QPushButton(config.thisTranslation["speak"])
speakButton.setFixedWidth(100)
speakButton.clicked.connect(self.speakCommandFieldText)
ttsLayout.addWidget(speakButton)
stopButton = QPushButton(config.thisTranslation["stop"])
stopButton.setFixedWidth(100)
stopButton.clicked.connect(
self.parent.textCommandParser.stopTtsAudio)
ttsLayout.addWidget(stopButton)
ttsLayout.addStretch()
commandBox.addLayout(ttsLayout)
commandBar.setLayout(commandBox)
mainLayout.addWidget(commandBar, 0, 0, Qt.AlignCenter)
self.tabs = QTabWidget()
self.tabs.currentChanged.connect(self.tabChanged)
mainLayout.addWidget(self.tabs, 1, 0, Qt.AlignCenter)
parser = BibleVerseParser(config.parserStandarisation)
self.bookMap = parser.standardAbbreviation
bookNums = list(self.bookMap.keys())
bookNumGps = [
bookNums[0:10],
bookNums[10:20],
bookNums[20:30],
bookNums[30:39],
bookNums[39:49],
bookNums[49:59],
bookNums[59:66],
]
bible = QWidget()
bible_layout = QVBoxLayout()
bible_layout.setMargin(0)
bible_layout.setSpacing(0)
for bookNumGp in bookNumGps[0:5]:
gp = QWidget()
layout = self.newRowLayout()
for bookNum in bookNumGp:
text = self.bookMap[bookNum]
button = QPushButton(text)
button.clicked.connect(partial(self.bibleBookAction, bookNum))
layout.addWidget(button)
gp.setLayout(layout)
bible_layout.addWidget(gp)
for bookNumGp in bookNumGps[5:]:
gp = QWidget()
layout = self.newRowLayout()
for bookNum in bookNumGp:
text = self.bookMap[bookNum]
button = QPushButton(text)
button.clicked.connect(partial(self.bibleBookAction, bookNum))
layout.addWidget(button)
gp.setLayout(layout)
bible_layout.addWidget(gp)
bible_layout.addStretch()
bible.setLayout(bible_layout)
self.tabs.addTab(bible, config.thisTranslation["bible"])
bibles_box = QWidget()
box_layout = QVBoxLayout()
box_layout.setMargin(0)
box_layout.setSpacing(0)
row_layout = self.newRowLayout()
biblesSqlite = BiblesSqlite()
bibles = biblesSqlite.getBibleList()
count = 0
for bible in bibles:
button = QPushButton(bible)
button.clicked.connect(partial(self.bibleAction, bible))
row_layout.addWidget(button)
count += 1
if count > 6:
count = 0
box_layout.addLayout(row_layout)
row_layout = self.newRowLayout()
box_layout.addLayout(row_layout)
box_layout.addStretch()
bibles_box.setLayout(box_layout)
self.tabs.addTab(bibles_box, config.thisTranslation["translations"])
commentaries_box = QWidget()
box_layout = QVBoxLayout()
box_layout.setMargin(0)
box_layout.setSpacing(0)
row_layout = self.newRowLayout()
commentaries = Commentary().getCommentaryList()
count = 0
for commentary in commentaries:
button = QPushButton(commentary)
button.clicked.connect(partial(self.commentaryAction, commentary))
row_layout.addWidget(button)
count += 1
if count > 6:
count = 0
box_layout.addLayout(row_layout)
row_layout = self.newRowLayout()
box_layout.addLayout(row_layout)
box_layout.addStretch()
commentaries_box.setLayout(box_layout)
self.tabs.addTab(commentaries_box,
config.thisTranslation["commentaries"])
lexicons_box = QWidget()
box_layout = QVBoxLayout()
box_layout.setMargin(0)
box_layout.setSpacing(0)
row_layout = self.newRowLayout()
lexicons = LexiconData().lexiconList
count = 0
for lexicon in lexicons:
button = QPushButton(lexicon)
button.clicked.connect(partial(self.lexiconAction, lexicon))
row_layout.addWidget(button)
count += 1
if count > 6:
count = 0
box_layout.addLayout(row_layout)
row_layout = self.newRowLayout()
box_layout.addLayout(row_layout)
box_layout.addStretch()
lexicons_box.setLayout(box_layout)
self.tabs.addTab(lexicons_box, config.thisTranslation["lexicons"])
dictionaries_box = QWidget()
box_layout = QVBoxLayout()
box_layout.setMargin(0)
box_layout.setSpacing(0)
row_layout = self.newRowLayout()
dictionaries = IndexesSqlite().dictionaryList
count = 0
for dictionary in dictionaries:
button = QPushButton(dictionary[0])
button.setToolTip(dictionary[1])
button.clicked.connect(
partial(self.dictionaryAction, dictionary[0]))
row_layout.addWidget(button)
count += 1
if count > 6:
count = 0
box_layout.addLayout(row_layout)
row_layout = self.newRowLayout()
box_layout.addLayout(row_layout)
box_layout.addStretch()
dictionaries_box.setLayout(box_layout)
self.tabs.addTab(dictionaries_box,
config.thisTranslation["dictionaries"])
self.tabs.setCurrentIndex(config.miniControlInitialTab)
self.setLayout(mainLayout)
def create_layout(self):
'''
Creates the complete layout including all controls
'''
self.title_label = ElidingLabel(text=self.dock_widget.windowTitle())
self.title_label.set_elide_mode(Qt.ElideRight)
self.title_label.setObjectName("dockWidgetTabLabel")
self.title_label.setAlignment(Qt.AlignCenter)
self.close_button = QPushButton()
self.close_button.setObjectName("tabCloseButton")
set_button_icon(self.public.style(), self.close_button,
QStyle.SP_TitleBarCloseButton)
self.close_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.close_button.setVisible(False)
self.close_button.setToolTip("Close Tab")
self.close_button.clicked.connect(self.public.close_requested)
fm = QFontMetrics(self.title_label.font())
spacing = round(fm.height() / 4.0)
# Fill the layout
layout = QBoxLayout(QBoxLayout.LeftToRight)
layout.setContentsMargins(2 * spacing, 0, 0, 0)
layout.setSpacing(0)
self.public.setLayout(layout)
layout.addWidget(self.title_label, 1)
layout.addSpacing(spacing)
layout.addWidget(self.close_button)
layout.addSpacing(round(spacing * 4.0 / 3.0))
layout.setAlignment(Qt.AlignCenter)
self.title_label.setVisible(True)
def __init__(self, parent=None):
super(AbstractColorDelegate, self).__init__(parent=parent)
# create scene
QBoxLayout(QBoxLayout.TopToBottom, self)
self._color = QColor(128, 128, 255)
def __init__(self, item):
super().__init__()
self._shown = False
self.modified_callback = None
scene = QGraphicsScene()
self.scene = scene
self.scene_item = item
scene.addItem(item)
layout = QBoxLayout(QBoxLayout.TopToBottom, self)
scene_view = View(self)
self.scene_view = scene_view
scene_view.setScene(scene)
scene_view.setMinimumSize(350, 350)
scene_view.setRenderHint(QPainter.Antialiasing)
layout.addWidget(scene_view)
self.double_click_callback = None
self.mouse_press_callback = None
if hasattr(self.scene_item, "mouse_pressed_in"):
self.mouse_press_callback = self.scene_item.mouse_pressed_in
if hasattr(self.scene_item, "double_clicked_in_background"):
self.double_click_callback = \
self.scene_item.double_clicked_in_background
if hasattr(self.scene_item, "mouse_moved_in_scene"):
self.scene_view.mouse_move_callback = \
self.scene_item.mouse_moved_in_scene
self.menus = []
view_menu = QMenu("&View")
self.view_menu = view_menu
self.menus.append(view_menu)
export_menu = QMenu("&Export")
self.menus.append(export_menu)
self.tools = []
fit_action = QAction("&Fit", self)
fit_action.setShortcut("0")
fit_action.setIcon(QIcon.fromTheme("zoom-fit-best"))
fit_action.setStatusTip("Fit the entire scene to the viewport")
fit_action.triggered.connect(self.scene_view.fit_all_in_view)
view_menu.addAction(fit_action)
self.tools.append(fit_action)
reset_action = QAction("&Reset (1:1)", self)
reset_action.setShortcut("9")
reset_action.setIcon(QIcon.fromTheme("zoom-original"))
reset_action.setStatusTip("Reset the view to 100% scale")
reset_action.triggered.connect(self.scene_view.reset_scale)
view_menu.addAction(reset_action)
self.tools.append(reset_action)
zoom_in_action = QAction("Zoom &In", self)
zoom_in_action.setShortcuts(["+", "="])
zoom_in_action.setStatusTip("Zoom in")
zoom_in_action.triggered.connect(lambda: self.scene_view.zoom_in())
view_menu.addAction(zoom_in_action)
zoom_out_action = QAction("Zoom &Out", self)
zoom_out_action.setShortcuts(["-", "_"])
zoom_out_action.setStatusTip("Zoom out")
zoom_out_action.triggered.connect(lambda: self.scene_view.zoom_out())
view_menu.addAction(zoom_out_action)
export_svg_action = QAction("As &SVG...", self)
export_svg_action.setStatusTip("Export the current tab as an SVG file")
export_svg_action.triggered.connect(lambda: export_as_svg(self.scene))
export_menu.addAction(export_svg_action)
export_png_action = QAction("As PN&G...", self)
export_png_action.setStatusTip("Export the current tab as an PNG file")
export_png_action.triggered.connect(lambda: export_as_png(self.scene))
export_menu.addAction(export_png_action)
export_pdf_action = QAction("As &PDF...", self)
export_pdf_action.setStatusTip("Export the current tab as an PDF file")
export_pdf_action.triggered.connect(lambda: export_as_pdf(self.scene))
export_menu.addAction(export_pdf_action)
export_svg_clip_action = QAction("To Clipboard as SVG", self)
export_svg_clip_action.setStatusTip(
"Export the current tab to the clipoard in SVG format")
export_svg_clip_action.triggered.connect(
lambda: export_to_clipboard_as_svg(self.scene))
export_menu.addAction(export_svg_clip_action)
export_image_clip_action = QAction("To &Clipboard as Image", self)
export_image_clip_action.setStatusTip(
"Export the current tab to the clipoard as an image")
export_image_clip_action.triggered.connect(
lambda: export_to_clipboard_as_image(self.scene))
export_menu.addAction(export_image_clip_action)
self.resize(800, 600)
def create_layout(self):
'''
Creates the complete layout including all controls
'''
self.title_label = ElidingLabel()
self.title_label.set_elide_mode(Qt.ElideRight)
self.title_label.setText("DockWidget->windowTitle()")
self.title_label.setObjectName("floatingTitleLabel")
self.title_label.setAlignment(Qt.AlignLeft)
self.close_button = QPushButton()
self.close_button.setObjectName("floatingTitleCloseButton")
self.close_button.setFlat(True)
# self.close_button.setAutoRaise(True)
set_button_icon(self.public.style(), self.close_button,
QStyle.SP_TitleBarCloseButton)
self.close_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.close_button.setVisible(True)
self.close_button.setFocusPolicy(Qt.NoFocus)
self.close_button.clicked.connect(self.public.close_requested)
fm = QFontMetrics(self.title_label.font())
spacing = round(fm.height() / 4.0)
# Fill the layout
layout = QBoxLayout(QBoxLayout.LeftToRight)
layout.setContentsMargins(6, 0, 0, 0)
layout.setSpacing(0)
self.public.setLayout(layout)
layout.addWidget(self.title_label, 1)
layout.addSpacing(spacing)
layout.addWidget(self.close_button)
layout.setAlignment(Qt.AlignCenter)
self.title_label.setVisible(True)
def navigationLayout1(self):
navigationLayout1 = QBoxLayout(QBoxLayout.LeftToRight)
navigationLayout1.setSpacing(5)
# Version selection
self.versionCombo = QComboBox()
#self.textList = self.biblesSqlite.getBibleList()
self.textList = self.parent.textList
self.versionCombo.addItems(self.textList)
for index, fullName in enumerate(self.parent.textFullNameList):
self.versionCombo.setItemData(index, fullName, Qt.ToolTipRole)
initialIndex = 0
if self.text in self.textList:
initialIndex = self.textList.index(self.text)
self.versionCombo.setCurrentIndex(initialIndex)
navigationLayout1.addWidget(self.versionCombo)
# Book / Chapter / Verse selection
self.bookCombo = QComboBox()
navigationLayout1.addWidget(self.bookCombo)
self.chapterCombo = QComboBox()
navigationLayout1.addWidget(self.chapterCombo)
self.verseCombo = QComboBox()
navigationLayout1.addWidget(self.verseCombo)
# Initial setup
self.updateBookCombo()
# Interactive update in response to users selection
self.versionCombo.currentIndexChanged.connect(self.updateBookCombo)
self.bookCombo.currentIndexChanged.connect(
lambda index: self.updateChapterCombo(self.bookList[index], True))
self.chapterCombo.currentIndexChanged.connect(
lambda index: self.updateVerseCombo(self.chapterList[index], True))
self.verseCombo.currentIndexChanged.connect(self.updateV)
return navigationLayout1
class ExtendedTabWidget(QFrame):
'''
Like QTabWidget, except the tab bar is located elsewhere. Intended for use with ExtendedTabBar.
'''
def __init__(self):
super(ExtendedTabWidget, self).__init__()
self._tab_bar = None
self._stack = QStackedWidget()
self._main_layout = QBoxLayout(QBoxLayout.LeftToRight)
self._main_layout.setContentsMargins(0, 0, 0, 0)
self._main_layout.addWidget(self._stack)
self.setLayout(self._main_layout)
def _move_tab(self, from_, to):
'''
Handles tab moves so that the tab bar indices stay aligned with the widget stack indices.
'''
displaced_widget = self._stack.widget(from_)
moved_widget = self._stack.widget(to)
self._stack.removeWidget(moved_widget)
self._stack.removeWidget(displaced_widget)
self._stack.insertWidget(to, displaced_widget)
self._stack.insertWidget(from_, moved_widget)
self._stack.setCurrentIndex(self._tab_bar.currentIndex())
def setTabBar(self, tab_bar):
'''
Sets the tab bar that will be used to switch between tabs.
tab_bar
The tab bar to set as the controller of this widget.
'''
if self._tab_bar is not None:
raise Exception('Tab bar already set.')
self._tab_bar = tab_bar
tab_bar.currentChanged.connect(self._stack.setCurrentIndex)
tab_bar.tabCloseRequested.connect(self.closeTab)
tab_bar.tabMoved.connect(self._move_tab)
def closeTab(self, index):
'''
Closes a tab, removing from this widget, the tab bar, and deleting its widget.
index
Index of the tab to be closed.
'''
self._tab_bar.removeTab(index)
widget = self._stack.widget(index)
self._stack.removeWidget(widget)
widget.deleteLater()
self._stack.setCurrentIndex(self._tab_bar.currentIndex())
def addTab(self, widget, label):
'''
Adds a tab.
widget
The widget for the tab contents.
label
The name of the tab to show in the tab bar.
Returns the index of the added tab.
'''
index = self._tab_bar.addTab(label)
self._stack.insertWidget(index, widget)
return index
def count(self):
'''
Returns the number of widgets.
'''
return self._stack.count()
def widget(self, index):
'''
Returns the widget at the given index.
'''
return self._stack.widget(index)
def indexOf(self, widget):
'''
Returns the index of the given widget.
'''
return self._stack.indexOf(widget)
def setupUI(self):
textButtonStyle = "QPushButton {background-color: #151B54; color: white;} QPushButton:hover {background-color: #333972;} QPushButton:pressed { background-color: #515790;}"
mainLayout = QGridLayout()
commandBox = QVBoxLayout()
commandBox.setSpacing(3)
commandBar = QWidget()
commandLayout1 = QBoxLayout(QBoxLayout.LeftToRight)
commandLayout1.setSpacing(5)
self.searchLineEdit = QLineEdit()
self.searchLineEdit.setClearButtonEnabled(True)
self.searchLineEdit.setToolTip(
config.thisTranslation["enter_command_here"])
self.searchLineEdit.returnPressed.connect(self.searchLineEntered)
self.searchLineEdit.setFixedWidth(450)
commandLayout1.addWidget(self.searchLineEdit)
enterButton = QPushButton(config.thisTranslation["enter"])
enterButton.setFixedWidth(100)
enterButton.clicked.connect(self.searchLineEntered)
commandLayout1.addWidget(enterButton)
# commandLayout1.addStretch()
commandBox.addLayout(commandLayout1)
if config.showMiniKeyboardInMiniControl:
commandLayout2 = QBoxLayout(QBoxLayout.LeftToRight)
commandLayout2.setSpacing(5)
keys = [
'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', ':', '-',
',', '.', ' ', '<', 'X'
]
for key in keys:
button = QPushButton(key)
button.setMaximumWidth(30)
button.clicked.connect(partial(self.keyEntryAction, key))
commandLayout2.addWidget(button)
commandLayout2.addStretch()
commandBox.addLayout(commandLayout2)
if config.showMiniKeyboardInMiniControl and config.isTtsInstalled:
ttsLayout = QBoxLayout(QBoxLayout.LeftToRight)
ttsLayout.setSpacing(5)
self.languageCombo = QComboBox()
ttsLayout.addWidget(self.languageCombo)
if config.espeak:
languages = TtsLanguages().isoLang2epeakLang
else:
languages = TtsLanguages().isoLang2qlocaleLang
self.languageCodes = list(languages.keys())
for code in self.languageCodes:
self.languageCombo.addItem(languages[code][1])
# Check if selected tts engine has the language user specify.
if not (config.ttsDefaultLangauge in self.languageCodes):
config.ttsDefaultLangauge = "en"
# Set initial item
initialIndex = self.languageCodes.index(config.ttsDefaultLangauge)
self.languageCombo.setCurrentIndex(initialIndex)
# setting tts default language here is confusing; better place in menu
#setDefaultButton = QPushButton(config.thisTranslation["setDefault"])
#setDefaultButton.setFixedWidth(130)
#setDefaultButton.clicked.connect(self.setTtsDefaultLanguage)
#ttsLayout.addWidget(setDefaultButton)
speakButton = QPushButton(config.thisTranslation["speak"])
speakButton.setFixedWidth(100)
speakButton.clicked.connect(self.speakCommandFieldText)
ttsLayout.addWidget(speakButton)
stopButton = QPushButton(config.thisTranslation["stop"])
stopButton.setFixedWidth(100)
stopButton.clicked.connect(
self.parent.textCommandParser.stopTtsAudio)
ttsLayout.addWidget(stopButton)
ttsLayout.addStretch()
commandBox.addLayout(ttsLayout)
commandBar.setLayout(commandBox)
mainLayout.addWidget(commandBar, 0, 0, Qt.AlignCenter)
self.tabs = QTabWidget()
self.tabs.currentChanged.connect(self.tabChanged)
mainLayout.addWidget(self.tabs, 1, 0, Qt.AlignCenter)
parser = BibleVerseParser(config.parserStandarisation)
self.bookMap = parser.standardAbbreviation
bookNums = list(self.bookMap.keys())
self.bookNumGps = [
bookNums[0:10],
bookNums[10:20],
bookNums[20:30],
bookNums[30:39],
bookNums[39:49],
bookNums[49:59],
bookNums[59:69],
bookNums[69:79],
bookNums[79:86],
bookNums[86:94],
bookNums[94:99],
bookNums[99:104],
bookNums[104:110],
bookNums[110:119],
bookNums[119:124],
bookNums[124:129],
bookNums[129:139],
bookNums[139:149],
bookNums[149:159],
bookNums[159:169],
bookNums[169:174],
bookNums[174:179],
bookNums[179:189],
bookNums[189:199],
]
# Bible books tab
self.bible = QWidget()
self.populateBooksButtons(config.mainText)
self.tabs.addTab(self.bible, config.thisTranslation["bible"])
# Bible translations tab
self.biblesBox = QWidget()
self.biblesBoxContainer = QVBoxLayout()
collectionsLayout = self.newRowLayout()
if len(config.bibleCollections) > 0:
button = QPushButton("All")
button.setStyleSheet(textButtonStyle)
button.clicked.connect(partial(self.selectCollection, "All"))
collectionsLayout.addWidget(button)
count = 0
for collection in sorted(config.bibleCollections.keys()):
button = QPushButton(collection)
button.setStyleSheet(textButtonStyle)
button.clicked.connect(
partial(self.selectCollection, collection))
collectionsLayout.addWidget(button)
count += 1
if count > 5:
count = 0
self.biblesBoxContainer.addLayout(collectionsLayout)
collectionsLayout = self.newRowLayout()
self.biblesBoxContainer.addLayout(collectionsLayout)
self.bibleBoxWidget = QWidget()
self.bibleBoxLayout = QVBoxLayout()
self.bibleBoxLayout.setContentsMargins(0, 0, 0, 0)
self.bibleBoxLayout.setSpacing(1)
row_layout = self.newRowLayout()
row_layout.setContentsMargins(0, 0, 0, 0)
row_layout.setSpacing(1)
biblesSqlite = BiblesSqlite()
bibles = biblesSqlite.getBibleList()
count = 0
for bible in bibles:
button = QPushButton(bible)
if bible in config.bibleDescription:
button.setToolTip("{0}".format(config.bibleDescription[bible]))
button.clicked.connect(partial(self.bibleAction, bible))
row_layout.addWidget(button)
count += 1
if count > 6:
count = 0
self.bibleBoxLayout.addLayout(row_layout)
row_layout = self.newRowLayout()
self.bibleButtons[bible] = button
self.bibleBoxLayout.addLayout(row_layout)
self.bibleBoxLayout.addStretch()
self.biblesBoxContainer.addLayout(self.bibleBoxLayout)
self.biblesBoxContainer.addStretch()
self.biblesBox.setLayout(self.biblesBoxContainer)
self.tabs.addTab(self.biblesBox,
config.thisTranslation["translations"])
# Commentaries tab
commentaries_box = QWidget()
box_layout = QVBoxLayout()
box_layout.setContentsMargins(0, 0, 0, 0)
box_layout.setSpacing(1)
row_layout = self.newRowLayout()
button = QPushButton(config.thisTranslation["activeOnly"])
button.setStyleSheet(textButtonStyle)
button.clicked.connect(self.activeCommentaries)
row_layout.addWidget(button)
box_layout.addLayout(row_layout)
row_layout = self.newRowLayout()
commentaries = Commentary().getCommentaryList()
count = 0
for commentary in commentaries:
button = QPushButton(commentary)
button.setToolTip(Commentary.fileLookup[commentary])
button.clicked.connect(partial(self.commentaryAction, commentary))
self.commentaryButtons[commentary] = button
row_layout.addWidget(button)
count += 1
if count > 6:
count = 0
box_layout.addLayout(row_layout)
row_layout = self.newRowLayout()
box_layout.addLayout(row_layout)
box_layout.addStretch()
commentaries_box.setLayout(box_layout)
self.tabs.addTab(commentaries_box,
config.thisTranslation["commentaries"])
# Lexicons tab
lexicons_box = QWidget()
box_layout = QVBoxLayout()
box_layout.setContentsMargins(0, 0, 0, 0)
box_layout.setSpacing(1)
row_layout = self.newRowLayout()
lexicons = LexiconData().lexiconList
count = 0
for lexicon in lexicons:
button = QPushButton(lexicon)
if lexicon in config.lexiconDescription:
button.setToolTip("{0}".format(
config.lexiconDescription[lexicon]))
button.clicked.connect(partial(self.lexiconAction, lexicon))
row_layout.addWidget(button)
count += 1
if count > 6:
count = 0
box_layout.addLayout(row_layout)
row_layout = self.newRowLayout()
box_layout.addLayout(row_layout)
box_layout.addStretch()
lexicons_box.setLayout(box_layout)
self.tabs.addTab(lexicons_box, config.thisTranslation["lexicons"])
# Dictionaries tab
dictionaries_box = QWidget()
box_layout = QVBoxLayout()
box_layout.setContentsMargins(0, 0, 0, 0)
box_layout.setSpacing(1)
row_layout = self.newRowLayout()
dictionaries = IndexesSqlite().dictionaryList
count = 0
for dictionary in dictionaries:
button = QPushButton(dictionary[0])
button.setToolTip(dictionary[1])
button.clicked.connect(
partial(self.dictionaryAction, dictionary[0]))
row_layout.addWidget(button)
count += 1
if count > 6:
count = 0
box_layout.addLayout(row_layout)
row_layout = self.newRowLayout()
box_layout.addLayout(row_layout)
box_layout.addStretch()
dictionaries_box.setLayout(box_layout)
self.tabs.addTab(dictionaries_box,
config.thisTranslation["dictionaries"])
# Book intros tab
bookIntros_box = QWidget()
box_layout = QVBoxLayout()
box_layout.setContentsMargins(0, 0, 0, 0)
box_layout.setSpacing(1)
row_layout = self.newRowLayout()
button = QPushButton(config.thisTranslation["activeOnly"])
button.setStyleSheet(textButtonStyle)
button.clicked.connect(self.activeBookIntros)
row_layout.addWidget(button)
box_layout.addLayout(row_layout)
row_layout = self.newRowLayout()
commentaries = Commentary().getCommentaryList()
count = 0
for commentary in commentaries:
button = QPushButton(commentary)
button.setToolTip(Commentary.fileLookup[commentary])
button.clicked.connect(partial(self.bookIntroAction, commentary))
self.bookIntroButtons[commentary] = button
row_layout.addWidget(button)
count += 1
if count > 6:
count = 0
box_layout.addLayout(row_layout)
row_layout = self.newRowLayout()
box_layout.addLayout(row_layout)
box_layout.addStretch()
bookIntros_box.setLayout(box_layout)
self.tabs.addTab(bookIntros_box, config.thisTranslation["bookIntro"])
# Devotionals tab
if len(self.devotionals) > 0:
devotionals_box = QWidget()
box_layout = QVBoxLayout()
box_layout.setContentsMargins(0, 0, 0, 0)
box_layout.setSpacing(1)
row_layout = self.newRowLayout()
count = 0
for file in self.devotionals:
name = Path(file).stem
button = QPushButton(name)
# button.setToolTip(dictionary[1])
button.clicked.connect(partial(self.devotionalAction, name))
row_layout.addWidget(button)
count += 1
if count > 2:
count = 0
box_layout.addLayout(row_layout)
row_layout.addStretch()
row_layout = self.newRowLayout()
for i in range(count, 3):
button = QPushButton("")
row_layout.addWidget(button)
box_layout.addLayout(row_layout)
box_layout.addStretch()
devotionals_box.setLayout(box_layout)
self.tabs.addTab(devotionals_box,
config.thisTranslation["devotionals"])
self.tabs.setCurrentIndex(config.miniControlInitialTab)
self.setLayout(mainLayout)
class ExtendedTabBar(QFrame):
'''
A tab bar that has QToolBars to the left, right, and floating at the end of the tabs.
Note that although this class inherits from QFrame, __getattr__() trickery is used to "inherit"
the attributes of an internal object that inherits from QTabBar. This is done because it allows
the actual tab bar object to be placed in a layout with other widgets, while allowing this class
to be treated as the tab bar itself.
'''
RoundedNorth = QTabBar.RoundedNorth
RoundedSouth = QTabBar.RoundedSouth
RoundedWest = QTabBar.RoundedWest
RoundedEast = QTabBar.RoundedEast
TriangularNorth = QTabBar.TriangularNorth
TriangularSouth = QTabBar.TriangularSouth
TriangularWest = QTabBar.TriangularWest
TriangularEast = QTabBar.TriangularEast
def __init__(self):
super(ExtendedTabBar, self).__init__()
self._tab_bar = _NoMinimumWidthTabBar()
self._left_toolbar = QToolBar()
self._floating_toolbar = QToolBar()
self._right_toolbar = QToolBar()
# Setup the layout.
self._main_layout = QBoxLayout(QBoxLayout.LeftToRight)
self._main_layout.setContentsMargins(0, 0, 0, 0)
self._main_layout.setSpacing(0)
self._main_layout.addWidget(self._left_toolbar)
self._main_layout.addWidget(self._tab_bar)
self._main_layout.addWidget(self._floating_toolbar)
self._main_layout.addStretch()
self._main_layout.addWidget(self._right_toolbar)
self.setLayout(self._main_layout)
def __getattr__(self, name):
'''
Return the internal tab bar object's attributes if this class does not have the given
attribute.
'''
return self.__dict__.get(name, getattr(self._tab_bar, name))
def minimumSizeHint(self):
'''
Add on any margins to the minimum size hint. Keeps the widget from getting sized so that the
tab tops are cut off.
'''
margins = self._main_layout.contentsMargins()
minimum_size_hint = self._tab_bar.minimumSizeHint()
if self.shape() in {
QTabBar.RoundedNorth, QTabBar.RoundedSouth,
QTabBar.TriangularNorth, QTabBar.TriangularSouth
}:
return minimum_size_hint + QSize(0,
margins.top() + margins.bottom())
else:
return minimum_size_hint + QSize(margins.left() + margins.right(),
0)
def setShape(self, shape):
'''
Sets the tab shapes.
shape
One of:
ExtendedTabBar.RoundedNorth
ExtendedTabBar.RoundedSouth
ExtendedTabBar.RoundedWest
ExtendedTabBar.RoundedEast
ExtendedTabBar.TriangularNorth
ExtendedTabBar.TriangularSouth
ExtendedTabBar.TriangularWest
ExtendedTabBar.TriangularEast
'''
self._tab_bar.setShape(shape)
if shape in {
QTabBar.RoundedNorth, QTabBar.RoundedSouth,
QTabBar.TriangularNorth, QTabBar.TriangularSouth
}:
direction = QBoxLayout.LeftToRight
orientation = Qt.Horizontal
else:
direction = QBoxLayout.TopToBottom
orientation = Qt.Vertical
self._main_layout.setDirection(direction)
self._left_toolbar.setOrientation(orientation)
self._floating_toolbar.setOrientation(orientation)
self._right_toolbar.setOrientation(orientation)
@property
def left_toolbar(self):
'''
Returns the QToolBar to the left (top) of the tabs.
'''
return self._left_toolbar
@property
def floating_toolbar(self):
'''
Returns the QToolBar floating to the right (bottom) of the tabs.
'''
return self._floating_toolbar
@property
def right_toolbar(self):
'''
Returns the QToolBar to the right (bottom) of the tabs.
'''
return self._right_toolbar
def _move_widgets(widgets_list: List[Tuple[QWidget, int]],
layout1: QBoxLayout, layout2: QBoxLayout):
for el in widgets_list:
layout1.removeWidget(el[0])
layout2.addWidget(el[0], el[1])