def restore_ui(self):
"""Restore UI state from previous session."""
self.qsettings.beginGroup(self.settings_group)
window_size = self.qsettings.value("windowSize")
window_pos = self.qsettings.value("windowPosition")
window_state = self.qsettings.value("windowState")
window_maximized = self.qsettings.value("windowMaximized",
defaultValue='false')
n_screens = self.qsettings.value("n_screens", defaultValue=1)
self.qsettings.endGroup()
original_size = self.size()
if window_size:
self.resize(window_size)
if window_pos:
self.move(window_pos)
if window_state:
self.restoreState(window_state,
version=1) # Toolbar and dockWidget positions
if len(QGuiApplication.screens()) < int(n_screens):
# There are less screens available now than on previous application startup
self.move(0,
0) # Move this widget to primary screen position (0,0)
ensure_window_is_on_screen(self, original_size)
if window_maximized == 'true':
self.setWindowState(Qt.WindowMaximized)
def restore_ui(self):
"""Restore UI state from previous session."""
window_size = self.qsettings.value("dataPackageWidget/windowSize")
window_pos = self.qsettings.value("dataPackageWidget/windowPosition")
splitter_state = self.qsettings.value(
"dataPackageWidget/splitterState")
window_maximized = self.qsettings.value(
"dataPackageWidget/windowMaximized", defaultValue='false')
window_state = self.qsettings.value("dataPackageWidget/windowState")
n_screens = self.qsettings.value("mainWindow/n_screens",
defaultValue=1)
original_size = self.size()
if window_size:
self.resize(window_size)
if window_pos:
self.move(window_pos)
# noinspection PyArgumentList
if len(QGuiApplication.screens()) < int(n_screens):
# There are less screens available now than on previous application startup
self.move(0,
0) # Move this widget to primary screen position (0,0)
ensure_window_is_on_screen(self, original_size)
if window_maximized == 'true':
self.setWindowState(Qt.WindowMaximized)
if window_state:
self.restoreState(window_state,
version=1) # Toolbar and dockWidget positions
if splitter_state:
self.ui.splitter.restoreState(splitter_state)
def closeEvent(self, event):
"""Stores window's settings and accepts the event."""
if self._import_preview is not None:
self._settings.beginGroup(self._SETTINGS_GROUP_NAME)
self._settings.setValue("n_screens",
len(QGuiApplication.screens()))
if not self._import_preview.isHidden():
self._settings.setValue("windowSize", self.size())
self._settings.setValue("windowPosition", self.pos())
self._settings.setValue(
"windowMaximized",
self.windowState() == Qt.WindowMaximized)
for splitter in self._import_preview.findChildren(QSplitter):
self._settings.setValue(
splitter.objectName() + "_splitterState",
splitter.saveState())
elif self._preview_window_state:
self._settings.setValue("windowSize",
self._preview_window_state["size"])
self._settings.setValue("windowPosition",
self._preview_window_state["position"])
self._settings.setValue("windowMaximized",
self._preview_window_state.maximized)
for name, state in self._preview_window_state["splitters"]:
self._settings.setValue(name + "_splitterState", state)
self._settings.endGroup()
event.accept()
def restore_ui(self):
"""Restore UI state from previous session."""
qsettings = self._qsettings
qsettings.beginGroup(self.settings_group)
window_size = qsettings.value("windowSize")
window_pos = qsettings.value("windowPosition")
window_state = qsettings.value("windowState")
window_maximized = qsettings.value("windowMaximized",
defaultValue='false')
n_screens = qsettings.value("n_screens", defaultValue=1)
splitter_state = {}
for splitter in self.findChildren(QSplitter):
splitter_state[splitter] = qsettings.value(splitter.objectName() +
"_splitterState")
qsettings.endGroup()
original_size = self.size()
if window_size:
self.resize(window_size)
if window_pos:
self.move(window_pos)
if window_state:
self.restoreState(window_state,
version=1) # Toolbar and dockWidget positions
# noinspection PyArgumentList
if len(QGuiApplication.screens()) < int(n_screens):
# There are less screens available now than on previous application startup
self.move(0,
0) # Move this widget to primary screen position (0,0)
ensure_window_is_on_screen(self, original_size)
if window_maximized == 'true':
self.setWindowState(Qt.WindowMaximized)
for splitter, state in splitter_state.items():
if state:
splitter.restoreState(state)
def __init__(self, data_connection):
"""Initialize class."""
from ..ui.spine_datapackage_form import Ui_MainWindow # pylint: disable=import-outside-toplevel
super().__init__(
flags=Qt.Window
) # TODO: Set parent as toolbox here if it makes sense
# TODO: Maybe set the parent as ToolboxUI so that its stylesheet is inherited. This may need
# TODO: reimplementing the window minimizing and maximizing actions as well as setting the window modality
self._data_connection = data_connection
self.datapackage = None
self.descriptor_tree_context_menu = None
self.selected_resource_name = None
self.resource_data = dict()
self.resources_model = DatapackageResourcesModel(self)
self.fields_model = DatapackageFieldsModel(self)
self.foreign_keys_model = DatapackageForeignKeysModel(self)
self.resource_data_model = MinimalTableModel(self)
self.default_row_height = QFontMetrics(QFont("", 0)).lineSpacing()
max_screen_height = max(
[s.availableSize().height() for s in QGuiApplication.screens()])
self.visible_rows = int(max_screen_height / self.default_row_height)
self.err_msg = QErrorMessage(self)
self.remove_row_icon = QIcon(":/icons/minus.png")
self.progress_bar = QProgressBar()
self.progress_bar.hide()
self.focus_widget = None # Last widget which had focus before showing a menu from the menubar
# Set up the user interface from Designer.
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.setWindowIcon(QIcon(":/symbols/app.ico"))
self.qsettings = QSettings("SpineProject", "Spine Toolbox")
self.restore_ui()
self.add_toggle_view_actions()
# Add status bar to form
self.ui.statusbar.setFixedHeight(20)
self.ui.statusbar.setSizeGripEnabled(False)
self.ui.statusbar.setStyleSheet(STATUSBAR_SS)
self.ui.statusbar.addPermanentWidget(self.progress_bar)
self.ui.tableView_resources.setModel(self.resources_model)
self.ui.tableView_fields.setModel(self.fields_model)
self.ui.tableView_foreign_keys.setModel(self.foreign_keys_model)
self.ui.tableView_resource_data.setModel(self.resource_data_model)
self.ui.tableView_resources.verticalHeader().setDefaultSectionSize(
self.default_row_height)
self.ui.tableView_resource_data.verticalHeader().setDefaultSectionSize(
self.default_row_height)
self.ui.tableView_resource_data.horizontalHeader(
).setResizeContentsPrecision(self.visible_rows)
self.ui.tableView_fields.verticalHeader().setDefaultSectionSize(
self.default_row_height)
self.ui.tableView_fields.horizontalHeader().setResizeContentsPrecision(
self.visible_rows)
self.ui.tableView_foreign_keys.verticalHeader().setDefaultSectionSize(
self.default_row_height)
self.ui.tableView_foreign_keys.horizontalHeader(
).setResizeContentsPrecision(self.visible_rows)
self.connect_signals()
# Ensure this window gets garbage-collected when closed
self.setAttribute(Qt.WA_DeleteOnClose)
def __init__(self, db_mngr, *db_urls):
"""Initializes form.
Args:
db_mngr (SpineDBManager): The manager to use
*db_urls (tuple): Database url, codename.
"""
super().__init__(flags=Qt.Window)
from ..ui.data_store_view import Ui_MainWindow
self.db_urls = list(db_urls)
self.db_url = self.db_urls[0]
self.db_mngr = db_mngr
self.db_maps = [
self.db_mngr.get_db_map_for_listener(self, url, codename=codename)
for url, codename in self.db_urls
]
self.db_map = self.db_maps[0]
# Setup UI from Qt Designer file
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.takeCentralWidget()
self.setWindowIcon(QIcon(":/symbols/app.ico"))
self.setStyleSheet(MAINWINDOW_SS)
self.setAttribute(Qt.WA_DeleteOnClose)
self.qsettings = QSettings("SpineProject", "Spine Toolbox")
self.err_msg = QErrorMessage(self)
self.notification_stack = NotificationStack(self)
self.err_msg.setWindowTitle("Error")
self.parameter_tag_toolbar = ParameterTagToolBar(
self, self.db_mngr, *self.db_maps)
self.addToolBar(Qt.TopToolBarArea, self.parameter_tag_toolbar)
self.selected_ent_cls_ids = {
"object class": {},
"relationship class": {}
}
self.selected_ent_ids = {"object": {}, "relationship": {}}
self.selected_parameter_tag_ids = dict()
self.selected_param_def_ids = {
"object class": {},
"relationship class": {}
}
self.parameter_value_list_model = ParameterValueListModel(
self, self.db_mngr, *self.db_maps)
fm = QFontMetrics(QFont("", 0))
self.default_row_height = 1.2 * fm.lineSpacing()
max_screen_height = max(
[s.availableSize().height() for s in QGuiApplication.screens()])
self.visible_rows = int(max_screen_height / self.default_row_height)
self._selection_source = None
self._selection_locked = False
self._focusable_childs = [self.ui.treeView_parameter_value_list]
self.settings_group = 'treeViewWidget'
self.undo_action = None
self.redo_action = None
db_names = ", ".join(
["{0}[*]".format(db_map.codename) for db_map in self.db_maps])
self.setWindowTitle("{0} - Data store view ".format(db_names))
self.update_commit_enabled()
def _update_screen_info(self):
virtual_screen = QRect(0, 0, 0, 0)
for screen in QGuiApplication.screens():
geom = screen.virtualGeometry()
virtual_screen = virtual_screen.united(geom)
self._screen_info = virtual_screen
self.screen_update_signal.emit()
def save_window_state(self):
"""Save window state parameters (size, position, state) via QSettings."""
self.qsettings.beginGroup(self.settings_group)
self.qsettings.setValue("windowSize", self.size())
self.qsettings.setValue("windowPosition", self.pos())
self.qsettings.setValue("windowState", self.saveState(version=1))
self.qsettings.setValue("windowMaximized",
self.windowState() == Qt.WindowMaximized)
self.qsettings.setValue("n_screens", len(QGuiApplication.screens()))
self.qsettings.endGroup()
def run_spp():
app = QApplication([])
global screen
screen = QGuiApplication.screens()[0]
main = Changewall()
main.resize_move()
main.setWindowTitle('Changewall')
main.show()
main.load()
sys.exit(app.exec_())
def __init__(self, datapackage):
"""Initialize class.
Args:
datapackage (CustomPackage): Data package associated to this widget
"""
from ..ui.spine_datapackage_form import Ui_MainWindow # pylint: disable=import-outside-toplevel
super().__init__(flags=Qt.Window)
self.datapackage = datapackage
self.selected_resource_index = None
self.resources_model = DatapackageResourcesModel(self, self.datapackage)
self.fields_model = DatapackageFieldsModel(self, self.datapackage)
self.foreign_keys_model = DatapackageForeignKeysModel(self, self.datapackage)
self.resource_data_model = DatapackageResourceDataModel(self, self.datapackage)
self.default_row_height = QFontMetrics(QFont("", 0)).lineSpacing()
max_screen_height = max([s.availableSize().height() for s in QGuiApplication.screens()])
self.visible_rows = int(max_screen_height / self.default_row_height)
self.err_msg = QErrorMessage(self)
self.notification_stack = NotificationStack(self)
self._foreign_keys_context_menu = QMenu(self)
self._file_watcher = QFileSystemWatcher(self)
self._file_watcher.addPath(self.datapackage.base_path)
self._changed_source_indexes = set()
self.undo_group = QUndoGroup(self)
self.undo_stacks = {}
self._save_resource_actions = []
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.takeCentralWidget()
self._before_save_all = self.ui.menuFile.insertSeparator(self.ui.actionSave_All)
self.setWindowIcon(QIcon(":/symbols/app.ico"))
self.qsettings = QSettings("SpineProject", "Spine Toolbox")
self.restore_ui()
self.add_menu_actions()
self.setStyleSheet(MAINWINDOW_SS)
self.ui.tableView_resources.setModel(self.resources_model)
self.ui.tableView_resources.verticalHeader().setDefaultSectionSize(self.default_row_height)
self.ui.tableView_resource_data.setModel(self.resource_data_model)
self.ui.tableView_resource_data.verticalHeader().setDefaultSectionSize(self.default_row_height)
self.ui.tableView_resource_data.horizontalHeader().setResizeContentsPrecision(self.visible_rows)
self.ui.tableView_fields.setModel(self.fields_model)
self.ui.tableView_fields.verticalHeader().setDefaultSectionSize(self.default_row_height)
self.ui.tableView_fields.horizontalHeader().setResizeContentsPrecision(self.visible_rows)
self.ui.tableView_foreign_keys.setModel(self.foreign_keys_model)
self.ui.tableView_foreign_keys.verticalHeader().setDefaultSectionSize(self.default_row_height)
self.ui.tableView_foreign_keys.horizontalHeader().setResizeContentsPrecision(self.visible_rows)
self.connect_signals()
self.setAttribute(Qt.WA_DeleteOnClose)
self.setWindowTitle("{0}[*] - Spine datapackage manager".format(self.datapackage.base_path))
self.load_datapackage()
def closeEvent(self, event=None):
"""Handle close event.
Args:
event (QEvent): Closing event if 'X' is clicked.
"""
# save qsettings
self.qsettings.setValue("dataPackageWidget/windowSize", self.size())
self.qsettings.setValue("dataPackageWidget/windowPosition", self.pos())
self.qsettings.setValue("dataPackageWidget/windowState", self.saveState(version=1))
self.qsettings.setValue("dataPackageWidget/windowMaximized", self.windowState() == Qt.WindowMaximized)
self.qsettings.setValue("dataPackageWidget/n_screens", len(QGuiApplication.screens()))
if event:
event.accept()
def screen_info(widget):
"""Format information on the screens"""
policy = QGuiApplication.highDpiScaleFactorRoundingPolicy()
policy_string = str(policy).split('.')[-1]
result = "<p>High DPI scale factor rounding policy: {}</p><ol>".format(
policy_string)
for screen in QGuiApplication.screens():
current = screen == widget.screen()
result += "<li>"
if current:
result += "<i>"
result += '"{}" {} {}DPI, DPR={}'.format(
screen.name(), format_geometry(screen.geometry()),
int(screen.logicalDotsPerInchX()), screen.devicePixelRatio())
if current:
result += "</i>"
result += "</li>"
result += "</ol>"
return result
def _restore_preview_ui(self):
"""Restore UI state from previous session."""
if not self._preview_window_state:
self._settings.beginGroup(self._SETTINGS_GROUP_NAME)
window_size = self._settings.value("windowSize")
window_pos = self._settings.value("windowPosition")
n_screens = self._settings.value("n_screens", defaultValue=1)
window_maximized = self._settings.value("windowMaximized",
defaultValue='false')
splitter_state = {}
for splitter in self._import_preview.findChildren(QSplitter):
splitter_state[splitter] = self._settings.value(
splitter.objectName() + "_splitterState")
self._settings.endGroup()
original_size = self.size()
if window_size:
self.resize(window_size)
else:
self.setGeometry(
QStyle.alignedRect(
Qt.LeftToRight, Qt.AlignCenter, QSize(1000, 700),
QApplication.desktop().availableGeometry(self)))
if window_pos:
self.move(window_pos)
if len(QGuiApplication.screens()) < int(n_screens):
# There are less screens available now than on previous application startup
self.move(
0, 0) # Move this widget to primary screen position (0,0)
ensure_window_is_on_screen(self, original_size)
if window_maximized == 'true':
self.setWindowState(Qt.WindowMaximized)
for splitter, state in splitter_state.items():
if state:
splitter.restoreState(state)
else:
self.resize(self._preview_window_state["size"])
self.move(self._preview_window_state["position"])
self.setWindowState(self._preview_window_state["maximized"])
for splitter in self._import_preview.findChildren(QSplitter):
name = splitter.objectName()
splitter.restoreState(
self._preview_window_state["splitters"][name])
def __init__(self, db_mngr):
"""Initializes form.
Args:
db_mngr (SpineDBManager): The manager to use
"""
super().__init__(flags=Qt.Window)
from ..ui.spine_db_editor_window import Ui_MainWindow # pylint: disable=import-outside-toplevel
self.db_mngr = db_mngr
self.db_maps = []
self.db_urls = []
self._change_notifiers = []
self._changelog = []
self.db_url = None
self._fetcher = None
# Setup UI from Qt Designer file
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.takeCentralWidget()
self.url_toolbar = UrlToolBar(self)
self.addToolBar(Qt.TopToolBarArea, self.url_toolbar)
self.setStyleSheet(MAINWINDOW_SS)
self.setAttribute(Qt.WA_DeleteOnClose)
self.qsettings = self.db_mngr.qsettings
self.err_msg = QErrorMessage(self)
self.err_msg.setWindowTitle("Error")
self.err_msg.setWindowFlag(Qt.WindowContextHelpButtonHint, False)
self.notification_stack = NotificationStack(self)
self.silenced = False
fm = QFontMetrics(QFont("", 0))
self.default_row_height = 1.2 * fm.lineSpacing()
max_screen_height = max(
[s.availableSize().height() for s in QGuiApplication.screens()])
self.visible_rows = int(max_screen_height / self.default_row_height)
self.settings_group = "spineDBEditor"
self.undo_action = None
self.redo_action = None
self.ui.actionUndo.setShortcuts(QKeySequence.Undo)
self.ui.actionRedo.setShortcuts(QKeySequence.Redo)
self.update_commit_enabled()
self.setContextMenuPolicy(Qt.NoContextMenu)
def closeEvent(self, event=None):
"""Handle close window.
Args:
event (QEvent): Closing event if 'X' is clicked.
"""
qsettings = self._qsettings
qsettings.beginGroup(self.settings_group)
for splitter in self.findChildren(QSplitter):
qsettings.setValue(splitter.objectName() + "_splitterState",
splitter.saveState())
qsettings.setValue("windowSize", self.size())
qsettings.setValue("windowPosition", self.pos())
qsettings.setValue("windowState", self.saveState(version=1))
qsettings.setValue("windowMaximized",
self.windowState() == Qt.WindowMaximized)
qsettings.setValue("n_screens", len(QGuiApplication.screens()))
qsettings.endGroup()
if event:
event.accept()
def __init__(self):
super().__init__(flags=Qt.Widget
| Qt.FramelessWindowHint
| Qt.BypassWindowManagerHint
| Qt.WindowTransparentForInput
| Qt.WindowStaysOnTopHint)
self.logger = logging.getLogger(__name__ + "." +
self.__class__.__name__)
self.setAttribute(Qt.WA_NoSystemBackground, True)
self.setAttribute(Qt.WA_TranslucentBackground, True)
self.setAttribute(Qt.WA_DeleteOnClose, True)
self.setStyleSheet("background: transparent")
self._instances = {}
virtual_screen = QRect(0, 0, 0, 0)
for screen in QGuiApplication.screens():
# TODO: Handle screen change
geom = screen.virtualGeometry()
virtual_screen = virtual_screen.united(geom)
self.scene = QGraphicsScene(0,
0,
virtual_screen.width(),
virtual_screen.height(),
parent=self)
self.view = QGraphicsView(self.scene, self)
self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setStyleSheet("background: transparent")
self.view.setGeometry(0, 0, virtual_screen.width(),
virtual_screen.height())
self.view.setInteractive(False)
self.transparent_pen = QPen()
self.transparent_pen.setBrush(Qt.NoBrush)
self.setGeometry(virtual_screen)
def restore_ui(self):
"""Restore UI state from previous session."""
window_size = self.qsettings.value("{0}/windowSize".format(
self.settings_key))
window_pos = self.qsettings.value("{0}/windowPosition".format(
self.settings_key))
window_maximized = self.qsettings.value("{0}/windowMaximized".format(
self.settings_key),
defaultValue='false')
n_screens = self.qsettings.value("{0}/n_screens".format(
self.settings_key),
defaultValue=1)
if window_size:
self.resize(window_size)
if window_pos:
self.move(window_pos)
if window_maximized == 'true':
self.setWindowState(Qt.WindowMaximized)
# noinspection PyArgumentList
if len(QGuiApplication.screens()) < int(n_screens):
# There are less screens available now than on previous application startup
self.move(0,
0) # Move this widget to primary screen position (0,0)
#restore splitters
splitters = [self.ui.splitter_3, self.ui.splitter_2, self.ui.splitter]
splitter_keys = [
"/splitterSelectTable", "/splitterTableFilter",
"/splitterPivotFrozen"
]
splitter_states = [
self.qsettings.value(s)
for s in (self.settings_key + p for p in splitter_keys)
]
for state, splitter in zip(splitter_states, splitters):
if state:
splitter.restoreState(state)
def __init__(self):
self.screens = QGuiApplication.screens()
self.primary = QGuiApplication.primaryScreen()
if self.primary in self.screens:
self.screens.remove(self.primary)
import sys
import time
from PySide2.QtCore import Qt
from PySide2.QtGui import QPixmap, QGuiApplication
from PySide2.QtWidgets import QApplication, QLabel
from pyqt_screenshot.screenshot import Screenshot, constant
if __name__ == "__main__":
QApplication.setAttribute(Qt.AA_EnableHighDpiScaling)
qtApp = QApplication(sys.argv)
# main_window = QLabel()
# img = Screenshot.take_screenshot(constant.CLIPBOARD)
pos = Screenshot.take_screenshot_pos(constant.CLIPBOARD)
print(pos)
for i in range(10):
screen = QGuiApplication.screens()[0]
screenPixel = screen.grabWindow(0)
img = screenPixel.copy(pos)
print(img)
img.save('e:/abc_%03d.jpg' % i)
time.sleep(10)
# main_window.show()
# if img is not None:
# main_window.setPixmap(QPixmap(img))
qtApp.exec_()
def __init__(self, parent=None, *args, appctxt=None, **kwargs):
"""Initializes all GUI elements and a separate thread."""
super().__init__(parent)
self.appctxt = appctxt
self.worker = Worker(self)
self.workerThread = QThread()
self.worker.moveToThread(self.workerThread)
self.workerThread.finished.connect(self.worker.deleteLater)
self.worker.started.connect(self.startProgress)
self.worker.ended.connect(self.endProgress)
self.worker.translationsReady.connect(self.showTranslations)
self.workerThread.start()
screenGeometry = QGuiApplication.screens()[0].geometry()
self.setGeometry(screenGeometry.width() / 5,
screenGeometry.height() / 5,
screenGeometry.width() / 3,
screenGeometry.height() / 3)
self.setMinimumSize(screenGeometry.width() / 4,
screenGeometry.height() / 4)
self.fileMenu = self.menuBar().addMenu(self.tr("&File"))
self.exitAct = self.fileMenu.addAction(self.tr("&Exit"))
self.exitAct.setStatusTip(self.tr("Exit from FreeLingvo"))
self.exitAct.triggered.connect(self.close)
self.helpMenu = self.menuBar().addMenu(self.tr("&Help"))
self.aboutAct = self.helpMenu.addAction(self.tr("&About"))
self.aboutAct.setStatusTip(
self.tr("Show information about FreeLingvo"))
self.aboutAct.triggered.connect(self.about)
self.searchText = QLineEdit()
self.searchText.setPlaceholderText(
self.tr("What word(s) to look for?"))
self.searchText.setClearButtonEnabled(True)
self.searchText.returnPressed.connect(self.worker.findTranslations)
self.translateButton = QPushButton(self.tr("Translate"))
self.translateButton.clicked.connect(self.worker.findTranslations)
self.dictsCombo = QComboBox()
self.dictsCombo.setInsertPolicy(QComboBox.InsertAlphabetically)
self.dictsCombo.setToolTip(
self.tr("Dictionary used to search for words"))
dictNames = os.listdir(self.appctxt.get_resource("dictionaries"))
dictNames = [name.replace(".tei", "") for name in dictNames]
self.dictsCombo.addItems(dictNames)
self.dictsCombo.currentIndexChanged[str].connect(self.worker.loadDict)
self.dictsCombo.setCurrentIndex(1)
self.translationsBrowser = QTextBrowser()
self.translationsBrowser.setUndoRedoEnabled(True)
self.undoButton = QPushButton(
QIcon(self.appctxt.get_resource("images/arrow_back.png")), "")
self.undoButton.setEnabled(False)
self.undoButton.setToolTip(self.tr("Show previous translation"))
self.undoButton.clicked.connect(self.translationsBrowser.undo)
self.translationsBrowser.undoAvailable.connect(
self.undoButton.setEnabled)
self.redoButton = QPushButton(
QIcon(self.appctxt.get_resource("images/arrow_forward.png")), "")
self.redoButton.setEnabled(False)
self.redoButton.setToolTip(self.tr("Show next translation"))
self.redoButton.clicked.connect(self.translationsBrowser.redo)
self.translationsBrowser.redoAvailable.connect(
self.redoButton.setEnabled)
self.sizeLabel = QLabel(self.tr("Font size:"))
self.sizeCombo = QComboBox()
for size in QFontDatabase.standardSizes():
self.sizeCombo.addItem(str(size))
self.sizeCombo.setCurrentText(str(self.font().pointSize()))
self.sizeCombo.currentIndexChanged[str].connect(self.changeFontSize)
self.controlsLayout = QHBoxLayout()
self.controlsLayout.addWidget(self.searchText)
self.controlsLayout.addWidget(self.translateButton)
self.controlsLayout.addWidget(self.dictsCombo)
self.browserToolsLayout = QHBoxLayout()
self.browserToolsLayout.addWidget(self.undoButton)
self.browserToolsLayout.addWidget(self.redoButton)
self.browserToolsLayout.addStretch(1)
self.browserToolsLayout.addWidget(self.sizeLabel)
self.browserToolsLayout.addWidget(self.sizeCombo)
self.centralLayout = QVBoxLayout()
self.centralLayout.addLayout(self.controlsLayout)
self.centralLayout.addLayout(self.browserToolsLayout)
self.centralLayout.addWidget(self.translationsBrowser)
centralWidget = QWidget()
centralWidget.setLayout(self.centralLayout)
self.setCentralWidget(centralWidget)
self.statusBar().showMessage(self.tr("Ready"), 2000)
