def __init__(self):
super(MainWindow, self).__init__()
toolBar = QToolBar()
self.addToolBar(toolBar)
file_menu = self.menuBar().addMenu('&File')
open_auction = QAction(QIcon.fromTheme('document-open'),
"&open..",
self,
shortcut=QKeySequence.Open,
triggered=self.open)
file_menu.addAction(open_auction)
exit_action = QAction(QIcon.fromTheme("application-exit"),
"E&xit",
self,
shortcut="Ctrl+q",
triggered=self.close)
file_menu.addAction(exit_action)
play_menu = self.menuBar().addMenu('&Play')
play_icon = QIcon(QPixmap(":/icons/01.png"))
# 增加一个Action到toolBar
toolBar.addAction(play_icon, "Play")
play_action = QAction(play_icon,
"E&s",
self,
shortcut="Ctrl+e",
triggered=self.close)
play_menu.addAction(play_action)
def __init__(self):
super(MainWindow, self).__init__()
self.cameraInfo = QCameraInfo.defaultCamera()
self.camera = QCamera(self.cameraInfo)
self.camera.setCaptureMode(QCamera.CaptureStillImage)
self.imageCapture = QCameraImageCapture(self.camera)
self.imageCapture.imageCaptured.connect(self.imageCaptured)
self.imageCapture.imageSaved.connect(self.imageSaved)
self.currentPreview = QImage()
toolBar = QToolBar()
self.addToolBar(toolBar)
fileMenu = self.menuBar().addMenu("&File")
shutterIcon = QIcon(
os.path.join(os.path.dirname(__file__), "shutter.svg"))
self.takePictureAction = QAction(shutterIcon,
"&Take Picture",
self,
shortcut="Ctrl+T",
triggered=self.takePicture)
self.takePictureAction.setToolTip("Take Picture")
fileMenu.addAction(self.takePictureAction)
toolBar.addAction(self.takePictureAction)
exitAction = QAction(QIcon.fromTheme("application-exit"),
"E&xit",
self,
shortcut="Ctrl+Q",
triggered=self.close)
fileMenu.addAction(exitAction)
aboutMenu = self.menuBar().addMenu("&About")
aboutQtAction = QAction("About &Qt", self, triggered=qApp.aboutQt)
aboutMenu.addAction(aboutQtAction)
self.tabWidget = QTabWidget()
self.setCentralWidget(self.tabWidget)
self.cameraViewfinder = QCameraViewfinder()
self.camera.setViewfinder(self.cameraViewfinder)
self.tabWidget.addTab(self.cameraViewfinder, "Viewfinder")
if self.camera.status() != QCamera.UnavailableStatus:
name = self.cameraInfo.description()
self.setWindowTitle("PySide6 Camera Example (" + name + ")")
self.statusBar().showMessage("Starting: '" + name + "'", 5000)
self.camera.start()
else:
self.setWindowTitle("PySide6 Camera Example")
self.takePictureAction.setEnabled(False)
self.statusBar().showMessage("Camera unavailable", 5000)
def __init__(self):
super().__init__()
## declared variables
self.dir_path = "None selected"
self.filelist = ["Select Folder"]
self.filelistindex = None
self.setWindowTitle("Ephys-Quick Analysis")
layout = QGridLayout()
toolbar = QToolBar("Function toolbar")
self.addToolBar(toolbar)
self.folderbuttonsetup()
toolbar.addAction(self.folderbutton)
self.setStatusBar(QStatusBar(self))
self.filebox = QComboBox()
self.filebox.addItems(self.filelist)
layout.addWidget(self.filebox, 0, 0, 1, 2)
self.tracelabel = QLabel("Sweep number :")
layout.addWidget(self.tracelabel, 0, 2)
self.sweepslider = QSpinBox()
self.sweepslider.setMinimum(0)
self.sweepslider.setSingleStep(1)
layout.addWidget(self.sweepslider, 0, 3, 1, 2)
self.pw = pg.PlotWidget(name='Clamp') ## giving the plots names allows us to link their axes together
layout.addWidget(self.pw, 1, 0, 2, 5)
self.pw2 = pg.PlotWidget(name='ClampZoom') ## giving the plots names allows us to link their axes together
layout.addWidget(self.pw2, 1, 6, 2, 5)
self.pw3 = pg.PlotWidget(name='Stim')
layout.addWidget(self.pw3, 6, 0, 2, 5)
self.pw3.setXLink(self.pw)
self.pw4 = pg.PlotWidget(name='StimZoom')
layout.addWidget(self.pw4, 6, 6, 2, 5)
self.pw4.setXLink(self.pw2)
self.pw.setBackground('w')
self.pw2.setBackground('w')
self.pw3.setBackground('w')
self.pw4.setBackground('w')
widget = QWidget()
widget.setLayout(layout)
self.setCentralWidget(widget)
def __init__(self):
super(MainWindow, self).__init__()
toolBar = QToolBar()
self.addToolBar(toolBar)
fileMenu = self.menuBar().addMenu("&File")
loadAction = QAction("Load...", self, shortcut="Ctrl+L", triggered=self.load)
fileMenu.addAction(loadAction)
toolBar.addAction(loadAction)
exitAction = QAction("E&xit", self, shortcut="Ctrl+Q", triggered=self.close)
fileMenu.addAction(exitAction)
aboutMenu = self.menuBar().addMenu("&About")
aboutQtAct = QAction("About &Qt", self, triggered=qApp.aboutQt)
aboutMenu.addAction(aboutQtAct)
self.axWidget = QAxWidget()
self.setCentralWidget(self.axWidget)
def __init__(self):
super(MainWindow, self).__init__()
self.setWindowTitle("My App")
label = QLabel("Hello!")
label.setAlignment(Qt.AlignCenter)
self.setCentralWidget(label)
toolbar = QToolBar("My main toolbar")
self.addToolBar(toolbar)
button_action = QAction("Your button", self)
button_action.setStatusTip("This is your button")
button_action.triggered.connect(self.onMyToolBarButtonClick)
toolbar.addAction(button_action)
class AssetListDialog(ReferenceDataDialog):
def __init__(self):
ReferenceDataDialog.__init__(self)
self.table = "assets_ext"
self.model = AssetListModel(self.table, self.DataView)
self.DataView.setModel(self.model)
self.model.configureView()
self.setup_ui()
super()._init_completed()
def setup_ui(self):
self.search_field = "assets_ext.full_name"
self.setWindowTitle(self.tr("Assets"))
self.SearchFrame.setVisible(True)
self.Toggle.setVisible(False)
self.custom_editor = True
self.DataView.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.GroupLbl.setVisible(True)
self.GroupLbl.setText(self.tr("Asset type:"))
self.GroupCombo.setVisible(True)
self.group_key_field = self.model.group_by
self.group_key_index = self.model.fieldIndex(self.model.group_by)
self.group_fkey_field = "id"
self.filter_field = "currency_id"
relation_model = self.model.relationModel(self.group_key_index)
self.GroupCombo.setModel(relation_model)
self.GroupCombo.setModelColumn(relation_model.fieldIndex("name"))
self.group_id = relation_model.data(
relation_model.index(
0, relation_model.fieldIndex(self.group_fkey_field)))
self.toolbar = QToolBar(self)
self.search_layout.addWidget(self.toolbar)
action = self.toolbar.addAction(self.tr("Update data"))
action.setToolTip(self.tr("Update assets data from their exchanges"))
action.triggered.connect(self.updateExchangeData)
def locateItem(self, item_id):
type_id = self.model.getAssetType(item_id)
if type_id == 0:
return
self.GroupCombo.setCurrentIndex(type_id - 1)
item_idx = self.model.locateItem(item_id, use_filter=self._filter_text)
self.DataView.setCurrentIndex(item_idx)
def updateExchangeData(self):
QuoteDownloader().updataData()
def customEditor(self):
return AssetDialog()
class Ui_tfm(object):
def setupUi(self, tfm):
if not tfm.objectName():
tfm.setObjectName(u"tfm")
tfm.resize(800, 600)
tfm.setContextMenuPolicy(Qt.NoContextMenu)
tfm.setLocale(QLocale(QLocale.English, QLocale.UnitedStates))
self.action_menu = QAction(tfm)
self.action_menu.setObjectName(u"action_menu")
self.action_new_dir = QAction(tfm)
self.action_new_dir.setObjectName(u"action_new_dir")
self.action_new_file = QAction(tfm)
self.action_new_file.setObjectName(u"action_new_file")
self.action_back = QAction(tfm)
self.action_back.setObjectName(u"action_back")
self.action_up = QAction(tfm)
self.action_up.setObjectName(u"action_up")
self.action_home = QAction(tfm)
self.action_home.setObjectName(u"action_home")
self.action_go = QAction(tfm)
self.action_go.setObjectName(u"action_go")
self.action_forward = QAction(tfm)
self.action_forward.setObjectName(u"action_forward")
self.action_copy = QAction(tfm)
self.action_copy.setObjectName(u"action_copy")
self.action_paste = QAction(tfm)
self.action_paste.setObjectName(u"action_paste")
self.action_cut = QAction(tfm)
self.action_cut.setObjectName(u"action_cut")
self.action_show_hidden = QAction(tfm)
self.action_show_hidden.setObjectName(u"action_show_hidden")
self.action_show_hidden.setCheckable(True)
self.action_delete = QAction(tfm)
self.action_delete.setObjectName(u"action_delete")
self.action_rename = QAction(tfm)
self.action_rename.setObjectName(u"action_rename")
self.action_add_to_bookmarks = QAction(tfm)
self.action_add_to_bookmarks.setObjectName(u"action_add_to_bookmarks")
self.action_remove_bookmark = QAction(tfm)
self.action_remove_bookmark.setObjectName(u"action_remove_bookmark")
self.action_copy_path = QAction(tfm)
self.action_copy_path.setObjectName(u"action_copy_path")
self.action_extract_here = QAction(tfm)
self.action_extract_here.setObjectName(u"action_extract_here")
self.action_mount_iso = QAction(tfm)
self.action_mount_iso.setObjectName(u"action_mount_iso")
self.centralwidget = QWidget(tfm)
self.centralwidget.setObjectName(u"centralwidget")
self.horizontalLayout = QHBoxLayout(self.centralwidget)
self.horizontalLayout.setObjectName(u"horizontalLayout")
self.vsplit = QSplitter(self.centralwidget)
self.vsplit.setObjectName(u"vsplit")
self.vsplit.setOrientation(Qt.Horizontal)
self.hsplit = QSplitter(self.vsplit)
self.hsplit.setObjectName(u"hsplit")
self.hsplit.setOrientation(Qt.Vertical)
self.fs_tree = QTreeView(self.hsplit)
self.fs_tree.setObjectName(u"fs_tree")
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(1)
sizePolicy.setHeightForWidth(
self.fs_tree.sizePolicy().hasHeightForWidth())
self.fs_tree.setSizePolicy(sizePolicy)
self.fs_tree.setTabKeyNavigation(True)
self.fs_tree.setProperty("showDropIndicator", True)
self.fs_tree.setDragEnabled(False)
self.fs_tree.setDragDropMode(QAbstractItemView.DropOnly)
self.fs_tree.setDefaultDropAction(Qt.MoveAction)
self.fs_tree.setRootIsDecorated(False)
self.hsplit.addWidget(self.fs_tree)
self.fs_tree.header().setVisible(False)
self.bookmark_view = QListView(self.hsplit)
self.bookmark_view.setObjectName(u"bookmark_view")
self.bookmark_view.setContextMenuPolicy(Qt.ActionsContextMenu)
self.bookmark_view.setEditTriggers(QAbstractItemView.DoubleClicked
| QAbstractItemView.EditKeyPressed
| QAbstractItemView.SelectedClicked)
self.bookmark_view.setTabKeyNavigation(True)
self.bookmark_view.setDragDropOverwriteMode(True)
self.bookmark_view.setDragDropMode(QAbstractItemView.DropOnly)
self.bookmark_view.setDefaultDropAction(Qt.CopyAction)
self.bookmark_view.setAlternatingRowColors(True)
self.hsplit.addWidget(self.bookmark_view)
self.mounts_view = QListView(self.hsplit)
self.mounts_view.setObjectName(u"mounts_view")
self.mounts_view.setTabKeyNavigation(True)
self.mounts_view.setAlternatingRowColors(True)
self.hsplit.addWidget(self.mounts_view)
self.vsplit.addWidget(self.hsplit)
self.table_view = QTableView(self.vsplit)
self.table_view.setObjectName(u"table_view")
sizePolicy1 = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
sizePolicy1.setHorizontalStretch(1)
sizePolicy1.setVerticalStretch(0)
sizePolicy1.setHeightForWidth(
self.table_view.sizePolicy().hasHeightForWidth())
self.table_view.setSizePolicy(sizePolicy1)
self.table_view.viewport().setProperty("cursor",
QCursor(Qt.ArrowCursor))
self.table_view.setContextMenuPolicy(Qt.ActionsContextMenu)
self.table_view.setAcceptDrops(True)
self.table_view.setToolTipDuration(-3)
self.table_view.setEditTriggers(QAbstractItemView.AnyKeyPressed
| QAbstractItemView.EditKeyPressed
| QAbstractItemView.SelectedClicked)
self.table_view.setDragEnabled(True)
self.table_view.setDragDropMode(QAbstractItemView.DragDrop)
self.table_view.setDefaultDropAction(Qt.MoveAction)
self.table_view.setAlternatingRowColors(True)
self.table_view.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.table_view.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table_view.setTextElideMode(Qt.ElideMiddle)
self.table_view.setShowGrid(False)
self.table_view.setSortingEnabled(True)
self.table_view.setWordWrap(False)
self.vsplit.addWidget(self.table_view)
self.table_view.horizontalHeader().setDefaultSectionSize(150)
self.table_view.horizontalHeader().setHighlightSections(False)
self.table_view.horizontalHeader().setStretchLastSection(True)
self.table_view.verticalHeader().setVisible(False)
self.horizontalLayout.addWidget(self.vsplit)
tfm.setCentralWidget(self.centralwidget)
self.statusbar = QStatusBar(tfm)
self.statusbar.setObjectName(u"statusbar")
self.statusbar.setContextMenuPolicy(Qt.NoContextMenu)
self.statusbar.setSizeGripEnabled(False)
tfm.setStatusBar(self.statusbar)
self.toolbar = QToolBar(tfm)
self.toolbar.setObjectName(u"toolbar")
self.toolbar.setContextMenuPolicy(Qt.PreventContextMenu)
self.toolbar.setMovable(False)
tfm.addToolBar(Qt.TopToolBarArea, self.toolbar)
self.toolbar.addAction(self.action_back)
self.toolbar.addAction(self.action_forward)
self.toolbar.addAction(self.action_up)
self.toolbar.addAction(self.action_home)
self.toolbar.addAction(self.action_go)
self.retranslateUi(tfm)
QMetaObject.connectSlotsByName(tfm)
# setupUi
def retranslateUi(self, tfm):
tfm.setWindowTitle(QCoreApplication.translate("tfm", u"tfm", None))
self.action_menu.setText(
QCoreApplication.translate("tfm", u"Menu", None))
self.action_new_dir.setText(
QCoreApplication.translate("tfm", u"New Directory", None))
self.action_new_file.setText(
QCoreApplication.translate("tfm", u"New File", None))
self.action_back.setText(
QCoreApplication.translate("tfm", u"Back", None))
self.action_up.setText(QCoreApplication.translate("tfm", u"Up", None))
self.action_home.setText(
QCoreApplication.translate("tfm", u"Home", None))
self.action_go.setText(QCoreApplication.translate("tfm", u"Go", None))
#if QT_CONFIG(tooltip)
self.action_go.setToolTip(
QCoreApplication.translate("tfm", u"Go or Reload", None))
#endif // QT_CONFIG(tooltip)
self.action_forward.setText(
QCoreApplication.translate("tfm", u"Forward", None))
self.action_copy.setText(
QCoreApplication.translate("tfm", u"Copy", None))
self.action_paste.setText(
QCoreApplication.translate("tfm", u"Paste", None))
self.action_cut.setText(QCoreApplication.translate(
"tfm", u"Cut", None))
self.action_show_hidden.setText(
QCoreApplication.translate("tfm", u"Show hidden files", None))
#if QT_CONFIG(shortcut)
self.action_show_hidden.setShortcut(
QCoreApplication.translate("tfm", u"Ctrl+H", None))
#endif // QT_CONFIG(shortcut)
self.action_delete.setText(
QCoreApplication.translate("tfm", u"Delete", None))
self.action_rename.setText(
QCoreApplication.translate("tfm", u"Rename", None))
self.action_add_to_bookmarks.setText(
QCoreApplication.translate("tfm", u"Add to bookmarks", None))
self.action_remove_bookmark.setText(
QCoreApplication.translate("tfm", u"Remove bookmark", None))
#if QT_CONFIG(tooltip)
self.action_remove_bookmark.setToolTip(
QCoreApplication.translate("tfm", u"Remove bookmark", None))
#endif // QT_CONFIG(tooltip)
self.action_copy_path.setText(
QCoreApplication.translate("tfm", u"Copy path", None))
self.action_extract_here.setText(
QCoreApplication.translate("tfm", u"Extract here", None))
#if QT_CONFIG(tooltip)
self.action_extract_here.setToolTip(
QCoreApplication.translate("tfm", u"Extract here", None))
#endif // QT_CONFIG(tooltip)
self.action_mount_iso.setText(
QCoreApplication.translate("tfm", u"Mount ISO", None))
#if QT_CONFIG(tooltip)
self.action_mount_iso.setToolTip(
QCoreApplication.translate("tfm", u"Mount ISO", None))
class MainWindow(QMainWindow):
"""Main application window"""
def __init__(self) -> None:
QMainWindow.__init__(self)
self.setSizePolicy(
QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum))
self.setMaximumSize(QSize(1920, 1080))
self.setStyleSheet("padding: 0px; margin: 0px;")
self.setIconSize(QSize(32, 32))
self.setWindowTitle("BossyBot 2000 - Image Tagger")
self.setWindowIcon(self.load_icon(icon))
self.menubar = QMenuBar(self)
self.menubar.setSizePolicy(EXP_MAX)
self.menubar.setMaximumSize(QSize(INFINITE, 30))
self.menu_file = QMenu('File', self.menubar)
self.menu_options = QMenu('Options', self.menubar)
self.menu_help = QMenu('Help', self.menubar)
self.menubar.addAction(self.menu_file.menuAction())
self.menubar.addAction(self.menu_options.menuAction())
self.menubar.addAction(self.menu_help.menuAction())
self.open = QAction('Open', self)
self.menu_file.addAction(self.open)
self.open.triggered.connect(self.open_file)
self.exit_button = QAction('Exit', self)
self.exit_button.triggered.connect(lambda: sys.exit(0),
Qt.QueuedConnection)
self.menu_file.addAction(self.exit_button)
self.setMenuBar(self.menubar)
self.previous_button = QAction(self.load_icon(previous), '<<', self)
self.next_button = QAction(self.load_icon(next_icon), '>>', self)
self.rotate_left_button = QAction(self.load_icon(left), '', self)
self.rotate_right_button = QAction(self.load_icon(right), '', self)
self.play_button = QAction(self.load_icon(play), '', self)
self.play_button.setCheckable(True)
self.delete_button = QAction(self.load_icon(delete), '', self)
self.reload_button = QAction(self.load_icon(reload), '', self)
self.mirror_button = QAction('Mirror', self)
self.actual_size_button = QAction('Actual Size', self)
self.browser_button = QAction('Browser', self)
self.browser_button.setCheckable(True)
self.browser_button.setChecked(True)
self.crop_button = QAction('Crop', self)
self.crop_button.setCheckable(True)
self.toolbuttons = {
self.rotate_left_button: {
'shortcut':
',',
'connect':
lambda: self.pixmap.setRotation(self.pixmap.rotation() - 90)
},
self.rotate_right_button: {
'shortcut':
'.',
'connect':
lambda: self.pixmap.setRotation(self.pixmap.rotation() + 90)
},
self.delete_button: {
'shortcut': 'Del',
'connect': self.delete
},
self.previous_button: {
'shortcut': 'Left',
'connect': self.previous
},
self.play_button: {
'shortcut': 'Space',
'connect': self.play
},
self.next_button: {
'shortcut': 'Right',
'connect': self.next
},
self.reload_button: {
'shortcut': 'F5',
'connect': self.reload
}
}
self.toolbar = QToolBar(self)
self.toolbar.setSizePolicy(EXP_MAX)
self.toolbar.setMaximumSize(QSize(INFINITE, 27))
for _ in (self.browser_button, self.crop_button, self.mirror_button,
self.actual_size_button):
self.toolbar.addAction(_)
self.addToolBar(Qt.TopToolBarArea, self.toolbar)
for button in self.toolbuttons:
button.setShortcut(self.toolbuttons[button]['shortcut'])
button.triggered.connect(self.toolbuttons[button]['connect'])
self.toolbar.addAction(button)
self.centralwidget = QWidget(self)
self.centralwidget.setSizePolicy(EXP_EXP)
self.setCentralWidget(self.centralwidget)
self.grid = QGridLayout(self.centralwidget)
self.media = QGraphicsScene(self)
self.media.setItemIndexMethod(QGraphicsScene.NoIndex)
self.media.setBackgroundBrush(QBrush(Qt.black))
self.view = MyView(self.media, self)
self.view.setSizePolicy(EXP_EXP)
self.media.setSceneRect(0, 0, self.view.width(), self.view.height())
self.grid.addWidget(self.view, 0, 0, 1, 1)
self.frame = QFrame(self.centralwidget)
self.frame.setSizePolicy(
QSizePolicy(QSizePolicy.Fixed, QSizePolicy.MinimumExpanding))
self.frame.setMinimumSize(QSize(325, 500))
self.frame.setStyleSheet(
"QFrame { border: 4px inset #222; border-radius: 10; }")
self.layout_widget = QWidget(self.frame)
self.layout_widget.setGeometry(QRect(0, 400, 321, 91))
self.layout_widget.setContentsMargins(15, 15, 15, 15)
self.grid2 = QGridLayout(self.layout_widget)
self.grid2.setContentsMargins(0, 0, 0, 0)
self.save_button = QPushButton('Yes (Save)', self.layout_widget)
self.save_button.setSizePolicy(FIX_FIX)
self.save_button.setMaximumSize(QSize(120, 26))
self.save_button.setVisible(False)
self.grid2.addWidget(self.save_button, 1, 0, 1, 1)
self.no_save_button = QPushButton('No (Reload)', self.layout_widget)
self.no_save_button.setSizePolicy(FIX_FIX)
self.no_save_button.setMaximumSize(QSize(120, 26))
self.no_save_button.setVisible(False)
self.grid2.addWidget(self.no_save_button, 1, 1, 1, 1)
self.label = QLabel("Current image modified, save it?",
self.layout_widget)
self.label.setSizePolicy(FIX_FIX)
self.label.setMaximumSize(QSize(325, 60))
self.label.setVisible(False)
self.label.setAlignment(Qt.AlignCenter)
self.grid2.addWidget(self.label, 0, 0, 1, 2)
self.layout_widget = QWidget(self.frame)
self.layout_widget.setGeometry(QRect(0, 0, 321, 213))
self.ass = QRadioButton('Ass', self.layout_widget)
self.ass_exposed = QRadioButton('Ass (exposed)', self.layout_widget)
self.ass_reset = QRadioButton(self.frame)
self.ass_group = QButtonGroup(self)
self.breasts = QRadioButton('Breasts', self.layout_widget)
self.breasts_exposed = QRadioButton('Breasts (exposed)',
self.layout_widget)
self.breasts_reset = QRadioButton(self.frame)
self.breasts_group = QButtonGroup(self)
self.pussy = QRadioButton('Pussy', self.layout_widget)
self.pussy_exposed = QRadioButton('Pussy (exposed)',
self.layout_widget)
self.pussy_reset = QRadioButton(self.frame)
self.pussy_group = QButtonGroup(self)
self.fully_clothed = QRadioButton('Fully Clothed', self.layout_widget)
self.fully_nude = QRadioButton('Fully Nude', self.layout_widget)
self.nudity_reset = QRadioButton(self.frame)
self.nudity = QButtonGroup(self)
self.smiling = QRadioButton('Smiling', self.layout_widget)
self.glaring = QRadioButton('Glaring', self.layout_widget)
self.expression_reset = QRadioButton(self.frame)
self.expression = QButtonGroup(self)
self.grid3 = QGridLayout(self.layout_widget)
self.grid3.setVerticalSpacing(15)
self.grid3.setContentsMargins(0, 15, 0, 0)
self.radios = {
self.ass: {
'this': 'ass',
'that': 'ass_exposed',
'group': self.ass_group,
'reset': self.ass_reset,
'grid': (0, 0, 1, 1)
},
self.ass_exposed: {
'this': 'ass_exposed',
'that': 'ass',
'group': self.ass_group,
'reset': self.ass_reset,
'grid': (0, 1, 1, 1)
},
self.breasts: {
'this': 'breasts',
'that': 'breasts_exposed',
'group': self.breasts_group,
'reset': self.breasts_reset,
'grid': (1, 0, 1, 1)
},
self.breasts_exposed: {
'this': 'breasts_exposed',
'that': 'breasts',
'group': self.breasts_group,
'reset': self.breasts_reset,
'grid': (1, 1, 1, 1)
},
self.pussy: {
'this': 'pussy',
'that': 'pussy_exposed',
'group': self.pussy_group,
'reset': self.pussy_reset,
'grid': (2, 0, 1, 1)
},
self.pussy_exposed: {
'this': 'pussy_exposed',
'that': 'pussy',
'group': self.pussy_group,
'reset': self.pussy_reset,
'grid': (2, 1, 1, 1)
},
self.fully_clothed: {
'this': 'fully_clothed',
'that': 'fully_nude',
'group': self.nudity,
'reset': self.nudity_reset,
'grid': (3, 0, 1, 1)
},
self.fully_nude: {
'this': 'fully_nude',
'that': 'fully_clothed',
'group': self.nudity,
'reset': self.nudity_reset,
'grid': (3, 1, 1, 1)
},
self.smiling: {
'this': 'smiling',
'that': 'glaring',
'group': self.expression,
'reset': self.expression_reset,
'grid': (4, 0, 1, 1)
},
self.glaring: {
'this': 'glaring',
'that': 'smiling',
'group': self.expression,
'reset': self.expression_reset,
'grid': (4, 1, 1, 1)
},
}
for radio in self.radios:
radio.setSizePolicy(FIX_FIX)
radio.setMaximumSize(QSize(150, 22))
self.radios[radio]['reset'].setGeometry(QRect(0, 0, 0, 0))
self.grid3.addWidget(radio, *self.radios[radio]['grid'])
if self.radios[radio]['group'] != self.nudity:
radio.toggled.connect(
lambda x=_, y=radio: self.annotate(self.radios[y]['this']))
self.radios[radio]['group'].addButton(radio)
self.radios[radio]['group'].addButton(self.radios[radio]['reset'])
self.save_tags_button = QPushButton('Save Tags', self.layout_widget)
self.save_tags_button.setSizePolicy(FIX_FIX)
self.save_tags_button.setMaximumSize(QSize(120, 26))
self.grid3.addWidget(self.save_tags_button, 5, 1, 1, 1)
self.grid.addWidget(self.frame, 0, 1, 1, 1)
self.browse_bar = QLabel(self.centralwidget)
self.browse_bar.setSizePolicy(EXP_FIX)
self.browse_bar.setMinimumSize(QSize(0, 100))
self.browse_bar.setMaximumSize(QSize(INFINITE, 100))
self.browse_bar.setStyleSheet("background: #000;")
self.browse_bar.setAlignment(Qt.AlignCenter)
self.h_box2 = QHBoxLayout(self.browse_bar)
self.h_box2.setContentsMargins(4, 0, 0, 0)
self.grid.addWidget(self.browse_bar, 1, 0, 1, 2)
hiders = [
self.no_save_button.clicked, self.save_button.clicked,
self.reload_button.triggered
]
for hider in hiders:
hider.connect(self.save_button.hide)
hider.connect(self.no_save_button.hide)
hider.connect(self.label.hide)
showers = [
self.mirror_button.triggered, self.rotate_right_button.triggered,
self.rotate_left_button.triggered
]
for shower in showers:
shower.connect(self.save_button.show)
shower.connect(self.no_save_button.show)
shower.connect(self.label.show)
self.no_save_button.clicked.connect(self.reload)
self.browser_button.toggled.connect(self.browse_bar.setVisible)
self.play_button.toggled.connect(lambda: self.frame.setVisible(
(True, False)[self.frame.isVisible()]))
self.reload_button.triggered.connect(self.reload)
self.mirror_button.triggered.connect(lambda: self.pixmap.setScale(-1))
self.save_button.clicked.connect(self.save_image)
self.play_button.toggled.connect(
lambda: self.browser_button.setChecked(
(True, False)[self.browse_bar.isVisible()]))
self.crop_button.toggled.connect(self.view.reset)
self.actual_size_button.triggered.connect(self.actual_size)
self.browser_button.triggered.connect(self.browser)
self.save_tags_button.clicked.connect(self.save_tags)
self.view.got_rect.connect(self.set_rect)
self.crop_rect = QRect(QPoint(0, 0), QSize(0, 0))
self.dir_now = os.getcwd()
self.files = []
self.index = 0
self.refresh_files()
self.pixmap_is_scaled = False
self.pixmap = QGraphicsPixmapItem()
self.active_tag = ''
self.reset_browser = False
self.txt = PngInfo()
def set_rect(self, rect: tuple[QPointF, QPointF]):
"""Converts the crop rectangle to a QRect after a crop action"""
self.crop_rect = QRect(rect[0].toPoint(), rect[1].toPoint())
def keyPressEvent(self, event: QKeyEvent): # pylint: disable=invalid-name;
"""Keyboard event handler."""
if event.key() == Qt.Key_Escape and self.play_button.isChecked():
self.play_button.toggle()
self.browser_button.setChecked((True, False)[self.reset_browser])
elif (event.key() in [16777220, 16777221]
and self.view.g_rect.rect().width() > 0):
self.view.got_rect.emit((self.view.g_rect.rect().topLeft(),
self.view.g_rect.rect().bottomRight()))
if self.view.g_rect.pen().color() == Qt.red:
new_pix = self.pixmap.pixmap().copy(self.crop_rect)
if self.pixmap_is_scaled:
new_pix = new_pix.transformed(
self.view.transform().inverted()[0],
Qt.SmoothTransformation)
self.update_pixmap(new_pix)
elif self.view.g_rect.pen().color() == Qt.magenta:
self.annotate_rect()
self.view.annotation = False
for _ in (self.label, self.save_button, self.no_save_button):
_.show()
self.view.reset()
def play(self):
"""Starts a slideshow."""
if self.play_button.isChecked():
if self.browser_button.isChecked():
self.reset_browser = True
else:
self.reset_browser = False
QTimer.singleShot(3000, self.play)
self.next()
def _yield_radio(self):
"""Saves code connecting signals from all the radio buttons."""
yield from self.radios.keys().__str__()
def load_icon(self, icon_file):
"""Loads an icon from Base64 encoded strings in icons.py."""
pix = QPixmap()
pix.loadFromData(icon_file)
return QIcon(pix)
def open_file(self, file: str) -> None:
"""
Open an image file and display it.
:param file: The filename of the image to open
"""
if not os.path.isfile(file):
file = QFileDialog(self, self.dir_now,
self.dir_now).getOpenFileName()[0]
self.dir_now = os.path.dirname(file)
self.refresh_files()
for i, index_file in enumerate(self.files):
if file.split('/')[-1] == index_file:
self.index = i
self.view.setTransform(QTransform())
self.update_pixmap(QPixmap(file))
self.browser()
self.load_tags()
def refresh_files(self) -> list[str]:
"""Updates the file list when the directory is changed.
Returns a list of image files available in the current directory."""
files = os.listdir(self.dir_now)
self.files = [
file for file in sorted(files, key=lambda x: x.lower())
if file.endswith((".png", ".jpg", ".gif", ".bmp", ".jpeg"))
]
def next(self) -> None:
"""Opens the next image in the file list."""
self.index = (self.index + 1) % len(self.files)
self.reload()
def previous(self) -> None:
"""Opens the previous image in the file list."""
self.index = (self.index + (len(self.files) - 1)) % len(self.files)
self.reload()
def save_image(self) -> None:
"""
Save the modified image file. If the current pixmap has been
scaled, we need to load a non-scaled pixmap from the original file and
re-apply the transformations that have been performed to prevent it
from being saved as the scaled-down image.
"""
if self.pixmap_is_scaled:
rotation = self.pixmap.rotation()
mirror = self.pixmap.scale() < 0
pix = QPixmap(self.files[self.index])
pix = pix.transformed(QTransform().rotate(rotation))
if mirror:
pix = pix.transformed(QTransform().scale(-1, 1))
pix.save(self.files[self.index], quality=-1)
else:
self.pixmap.pixmap().save(self.files[self.index], quality=-1)
self.save_tags()
def delete(self) -> None:
"""Deletes the current image from the file system."""
with suppress(OSError):
os.remove(f"{self.dir_now}/{self.files.pop(self.index)}")
self.refresh_files()
def reload(self) -> None:
"""Reloads the current pixmap; used to update the screen when the
current file is changed."""
self.open_file(f"{self.dir_now}/{self.files[self.index]}")
def annotate(self, tag):
"""Starts an annotate action"""
self.txt = PngInfo()
self.view.annotation = True
self.active_tag = tag
self.view.reset()
def wheelEvent(self, event: QWheelEvent) -> None: # pylint: disable=invalid-name
"""With Ctrl depressed, zoom the current image, otherwise fire the
next/previous functions."""
modifiers = QApplication.keyboardModifiers()
if event.angleDelta().y() == 120 and modifiers == Qt.ControlModifier:
self.view.scale(0.75, 0.75)
elif event.angleDelta().y() == 120:
self.previous()
elif event.angleDelta().y(
) == -120 and modifiers == Qt.ControlModifier:
self.view.scale(1.25, 1.25)
elif event.angleDelta().y() == -120:
self.next()
def actual_size(self) -> None:
"""Display the current image at its actual size, rather than scaled to
fit the viewport."""
self.update_pixmap(QPixmap(self.files[self.index]), False)
self.view.setDragMode(QGraphicsView.ScrollHandDrag)
def mousePressEvent(self, event: QMouseEvent) -> None: # pylint: disable=invalid-name
"""Event handler for mouse button presses."""
if event.button() == Qt.MouseButton.ForwardButton:
self.next()
elif event.button() == Qt.MouseButton.BackButton:
self.previous()
def update_pixmap(self, new: QPixmap, scaled: bool = True) -> None:
"""
Updates the currently displayed image.
:param new: The new `QPixmap` to be displayed.
:param scaled: If False, don't scale the image to fit the viewport.
"""
self.pixmap_is_scaled = scaled
self.media.clear()
self.pixmap = self.media.addPixmap(new)
self.pixmap.setTransformOriginPoint(
self.pixmap.boundingRect().width() / 2,
self.pixmap.boundingRect().height() / 2)
if scaled and (new.size().width() > self.view.width()
or new.size().height() > self.view.height()):
self.view.fitInView(self.pixmap, Qt.KeepAspectRatio)
self.media.setSceneRect(self.pixmap.boundingRect())
def annotate_rect(self):
"""Creates image coordinate annotation data."""
self.txt.add_itxt(
f'{str(self.active_tag)}-rect',
f'{str(self.crop_rect.x())}, {str(self.crop_rect.y())}, {str(self.crop_rect.width())}, {str(self.crop_rect.height())}'
)
def browser(self):
"""Slot function to initialize image thumbnails for the
'browse mode.'"""
while self.h_box2.itemAt(0):
self.h_box2.takeAt(0).widget().deleteLater()
index = (self.index + (len(self.files) - 2)) % len(self.files)
for i, file in enumerate(self.files):
file = self.dir_now + '/' + self.files[index]
label = ClickableLabel(self, file)
self.h_box2.addWidget(label)
pix = QPixmap(file)
if (pix.size().width() > self.browse_bar.width() / 5
or pix.size().height() > 100):
pix = pix.scaled(self.browse_bar.width() / 5, 100,
Qt.KeepAspectRatio)
label.setPixmap(pix)
index = (index + 1) % len(self.files)
if i == 4:
break
def save_tags(self):
"""Save tags for currently loaded image into its iTxt data."""
file = self.files[self.index]
img = Image.open(file)
img.load()
for key, value, in img.text.items():
self.txt.add_itxt(key, value)
for key in self.radios:
if key.isChecked():
self.txt.add_itxt(self.radios[key]['this'], 'True')
self.txt.add_itxt(self.radios[key]['that'], 'False')
img.save(file, pnginfo=self.txt)
def load_tags(self):
"""Load tags from iTxt data."""
for radio in self.radios:
if radio.isChecked():
self.radios[radio]['reset'].setChecked(True)
filename = self.files[self.index]
fqp = filename
img = Image.open(fqp)
img.load()
with suppress(AttributeError):
for key, value in img.text.items():
if value == 'True':
for radio in self.radios:
if key == self.radios[radio]['this']:
radio.setChecked(True)
self.view.annotation = False
self.active_tag = ''
self.view.reset()
for key, value in img.text.items():
if key.endswith('-rect'):
btn = [
radio for radio in self.radios
if self.radios[radio]['this'] == key.split('-')[0]
]
print(key, value)
if btn[0].isChecked():
coords = [int(coord) for coord in value.split(', ')]
rect = QGraphicsRectItem(*coords)
rect.setPen(QPen(Qt.magenta, 1, Qt.SolidLine))
rect.setBrush(QBrush(Qt.magenta, Qt.Dense4Pattern))
self.view.scene().addItem(rect)
text = self.view.scene().addText(
key.split('-')[0],
QFont('monospace', 20, 400, False))
text.font().setPointSize(text.font().pointSize() * 2)
text.update()
text.setX(rect.rect().x() + 10)
text.setY(rect.rect().y() + 10)
print(f'set {key}')
def __init__(self):
super(MainWindow, self).__init__()
self.playlist = QMediaPlaylist()
self.player = QMediaPlayer()
toolBar = QToolBar()
self.addToolBar(toolBar)
fileMenu = self.menuBar().addMenu("&File")
openAction = QAction(QIcon.fromTheme("document-open"),
"&Open...",
self,
shortcut=QKeySequence.Open,
triggered=self.open)
fileMenu.addAction(openAction)
exitAction = QAction(QIcon.fromTheme("application-exit"),
"E&xit",
self,
shortcut="Ctrl+Q",
triggered=self.close)
fileMenu.addAction(exitAction)
playMenu = self.menuBar().addMenu("&Play")
playIcon = self.style().standardIcon(QStyle.SP_MediaPlay)
self.playAction = toolBar.addAction(playIcon, "Play")
self.playAction.triggered.connect(self.player.play)
playMenu.addAction(self.playAction)
previousIcon = self.style().standardIcon(QStyle.SP_MediaSkipBackward)
self.previousAction = toolBar.addAction(previousIcon, "Previous")
self.previousAction.triggered.connect(self.previousClicked)
playMenu.addAction(self.previousAction)
pauseIcon = self.style().standardIcon(QStyle.SP_MediaPause)
self.pauseAction = toolBar.addAction(pauseIcon, "Pause")
self.pauseAction.triggered.connect(self.player.pause)
playMenu.addAction(self.pauseAction)
nextIcon = self.style().standardIcon(QStyle.SP_MediaSkipForward)
self.nextAction = toolBar.addAction(nextIcon, "Next")
self.nextAction.triggered.connect(self.playlist.next)
playMenu.addAction(self.nextAction)
stopIcon = self.style().standardIcon(QStyle.SP_MediaStop)
self.stopAction = toolBar.addAction(stopIcon, "Stop")
self.stopAction.triggered.connect(self.player.stop)
playMenu.addAction(self.stopAction)
self.volumeSlider = QSlider()
self.volumeSlider.setOrientation(Qt.Horizontal)
self.volumeSlider.setMinimum(0)
self.volumeSlider.setMaximum(100)
self.volumeSlider.setFixedWidth(
app.desktop().availableGeometry(self).width() / 10)
self.volumeSlider.setValue(self.player.volume())
self.volumeSlider.setTickInterval(10)
self.volumeSlider.setTickPosition(QSlider.TicksBelow)
self.volumeSlider.setToolTip("Volume")
self.volumeSlider.valueChanged.connect(self.player.setVolume)
toolBar.addWidget(self.volumeSlider)
aboutMenu = self.menuBar().addMenu("&About")
aboutQtAct = QAction("About &Qt", self, triggered=qApp.aboutQt)
aboutMenu.addAction(aboutQtAct)
self.videoWidget = QVideoWidget()
self.setCentralWidget(self.videoWidget)
self.player.setPlaylist(self.playlist)
self.player.stateChanged.connect(self.updateButtons)
self.player.setVideoOutput(self.videoWidget)
self.updateButtons(self.player.state())
class MainWindow(QMainWindow):
"""Provides the parent window that includes the BookmarkWidget,
BrowserTabWidget, and a DownloadWidget, to offer the complete
web browsing experience."""
def __init__(self):
super(MainWindow, self).__init__()
self.setWindowTitle('PySide6 tabbed browser Example')
self._tab_widget = BrowserTabWidget(create_main_window_with_browser)
self._tab_widget.enabled_changed.connect(self._enabled_changed)
self._tab_widget.download_requested.connect(self._download_requested)
self.setCentralWidget(self._tab_widget)
self.connect(self._tab_widget, QtCore.SIGNAL("url_changed(QUrl)"),
self.url_changed)
self._bookmark_dock = QDockWidget()
self._bookmark_dock.setWindowTitle('Bookmarks')
self._bookmark_widget = BookmarkWidget()
self._bookmark_widget.open_bookmark.connect(self.load_url)
self._bookmark_widget.open_bookmark_in_new_tab.connect(
self.load_url_in_new_tab)
self._bookmark_dock.setWidget(self._bookmark_widget)
self.addDockWidget(Qt.LeftDockWidgetArea, self._bookmark_dock)
self._find_tool_bar = None
self._actions = {}
self._create_menu()
self._tool_bar = QToolBar()
self.addToolBar(self._tool_bar)
for action in self._actions.values():
if not action.icon().isNull():
self._tool_bar.addAction(action)
self._addres_line_edit = QLineEdit()
self._addres_line_edit.setClearButtonEnabled(True)
self._addres_line_edit.returnPressed.connect(self.load)
self._tool_bar.addWidget(self._addres_line_edit)
self._zoom_label = QLabel()
self.statusBar().addPermanentWidget(self._zoom_label)
self._update_zoom_label()
self._bookmarksToolBar = QToolBar()
self.addToolBar(Qt.TopToolBarArea, self._bookmarksToolBar)
self.insertToolBarBreak(self._bookmarksToolBar)
self._bookmark_widget.changed.connect(self._update_bookmarks)
self._update_bookmarks()
def _update_bookmarks(self):
self._bookmark_widget.populate_tool_bar(self._bookmarksToolBar)
self._bookmark_widget.populate_other(self._bookmark_menu, 3)
def _create_menu(self):
file_menu = self.menuBar().addMenu("&File")
exit_action = QAction(QIcon.fromTheme("application-exit"),
"E&xit",
self,
shortcut="Ctrl+Q",
triggered=qApp.quit)
file_menu.addAction(exit_action)
navigation_menu = self.menuBar().addMenu("&Navigation")
style_icons = ':/qt-project.org/styles/commonstyle/images/'
back_action = QAction(QIcon.fromTheme(
"go-previous", QIcon(style_icons + 'left-32.png')),
"Back",
self,
shortcut=QKeySequence(QKeySequence.Back),
triggered=self._tab_widget.back)
self._actions[QWebEnginePage.Back] = back_action
back_action.setEnabled(False)
navigation_menu.addAction(back_action)
forward_action = QAction(QIcon.fromTheme(
"go-next", QIcon(style_icons + 'right-32.png')),
"Forward",
self,
shortcut=QKeySequence(QKeySequence.Forward),
triggered=self._tab_widget.forward)
forward_action.setEnabled(False)
self._actions[QWebEnginePage.Forward] = forward_action
navigation_menu.addAction(forward_action)
reload_action = QAction(QIcon(style_icons + 'refresh-32.png'),
"Reload",
self,
shortcut=QKeySequence(QKeySequence.Refresh),
triggered=self._tab_widget.reload)
self._actions[QWebEnginePage.Reload] = reload_action
reload_action.setEnabled(False)
navigation_menu.addAction(reload_action)
navigation_menu.addSeparator()
new_tab_action = QAction("New Tab",
self,
shortcut='Ctrl+T',
triggered=self.add_browser_tab)
navigation_menu.addAction(new_tab_action)
close_tab_action = QAction("Close Current Tab",
self,
shortcut="Ctrl+W",
triggered=self._close_current_tab)
navigation_menu.addAction(close_tab_action)
navigation_menu.addSeparator()
history_action = QAction("History...",
self,
triggered=self._tab_widget.show_history)
navigation_menu.addAction(history_action)
edit_menu = self.menuBar().addMenu("&Edit")
find_action = QAction("Find",
self,
shortcut=QKeySequence(QKeySequence.Find),
triggered=self._show_find)
edit_menu.addAction(find_action)
edit_menu.addSeparator()
undo_action = QAction("Undo",
self,
shortcut=QKeySequence(QKeySequence.Undo),
triggered=self._tab_widget.undo)
self._actions[QWebEnginePage.Undo] = undo_action
undo_action.setEnabled(False)
edit_menu.addAction(undo_action)
redo_action = QAction("Redo",
self,
shortcut=QKeySequence(QKeySequence.Redo),
triggered=self._tab_widget.redo)
self._actions[QWebEnginePage.Redo] = redo_action
redo_action.setEnabled(False)
edit_menu.addAction(redo_action)
edit_menu.addSeparator()
cut_action = QAction("Cut",
self,
shortcut=QKeySequence(QKeySequence.Cut),
triggered=self._tab_widget.cut)
self._actions[QWebEnginePage.Cut] = cut_action
cut_action.setEnabled(False)
edit_menu.addAction(cut_action)
copy_action = QAction("Copy",
self,
shortcut=QKeySequence(QKeySequence.Copy),
triggered=self._tab_widget.copy)
self._actions[QWebEnginePage.Copy] = copy_action
copy_action.setEnabled(False)
edit_menu.addAction(copy_action)
paste_action = QAction("Paste",
self,
shortcut=QKeySequence(QKeySequence.Paste),
triggered=self._tab_widget.paste)
self._actions[QWebEnginePage.Paste] = paste_action
paste_action.setEnabled(False)
edit_menu.addAction(paste_action)
edit_menu.addSeparator()
select_all_action = QAction("Select All",
self,
shortcut=QKeySequence(
QKeySequence.SelectAll),
triggered=self._tab_widget.select_all)
self._actions[QWebEnginePage.SelectAll] = select_all_action
select_all_action.setEnabled(False)
edit_menu.addAction(select_all_action)
self._bookmark_menu = self.menuBar().addMenu("&Bookmarks")
add_bookmark_action = QAction("&Add Bookmark",
self,
triggered=self._add_bookmark)
self._bookmark_menu.addAction(add_bookmark_action)
add_tool_bar_bookmark_action = QAction(
"&Add Bookmark to Tool Bar",
self,
triggered=self._add_tool_bar_bookmark)
self._bookmark_menu.addAction(add_tool_bar_bookmark_action)
self._bookmark_menu.addSeparator()
tools_menu = self.menuBar().addMenu("&Tools")
download_action = QAction(
"Open Downloads",
self,
triggered=DownloadWidget.open_download_directory)
tools_menu.addAction(download_action)
window_menu = self.menuBar().addMenu("&Window")
window_menu.addAction(self._bookmark_dock.toggleViewAction())
window_menu.addSeparator()
zoom_in_action = QAction(QIcon.fromTheme("zoom-in"),
"Zoom In",
self,
shortcut=QKeySequence(QKeySequence.ZoomIn),
triggered=self._zoom_in)
window_menu.addAction(zoom_in_action)
zoom_out_action = QAction(QIcon.fromTheme("zoom-out"),
"Zoom Out",
self,
shortcut=QKeySequence(QKeySequence.ZoomOut),
triggered=self._zoom_out)
window_menu.addAction(zoom_out_action)
reset_zoom_action = QAction(QIcon.fromTheme("zoom-original"),
"Reset Zoom",
self,
shortcut="Ctrl+0",
triggered=self._reset_zoom)
window_menu.addAction(reset_zoom_action)
about_menu = self.menuBar().addMenu("&About")
about_action = QAction("About Qt",
self,
shortcut=QKeySequence(
QKeySequence.HelpContents),
triggered=qApp.aboutQt)
about_menu.addAction(about_action)
def add_browser_tab(self):
return self._tab_widget.add_browser_tab()
def _close_current_tab(self):
if self._tab_widget.count() > 1:
self._tab_widget.close_current_tab()
else:
self.close()
def close_event(self, event):
main_windows.remove(self)
event.accept()
def load(self):
url_string = self._addres_line_edit.text().strip()
if url_string:
self.load_url_string(url_string)
def load_url_string(self, url_s):
url = QUrl.fromUserInput(url_s)
if (url.isValid()):
self.load_url(url)
def load_url(self, url):
self._tab_widget.load(url)
def load_url_in_new_tab(self, url):
self.add_browser_tab().load(url)
def url_changed(self, url):
self._addres_line_edit.setText(url.toString())
def _enabled_changed(self, web_action, enabled):
action = self._actions[web_action]
if action:
action.setEnabled(enabled)
def _add_bookmark(self):
index = self._tab_widget.currentIndex()
if index >= 0:
url = self._tab_widget.url()
title = self._tab_widget.tabText(index)
icon = self._tab_widget.tabIcon(index)
self._bookmark_widget.add_bookmark(url, title, icon)
def _add_tool_bar_bookmark(self):
index = self._tab_widget.currentIndex()
if index >= 0:
url = self._tab_widget.url()
title = self._tab_widget.tabText(index)
icon = self._tab_widget.tabIcon(index)
self._bookmark_widget.add_tool_bar_bookmark(url, title, icon)
def _zoom_in(self):
new_zoom = self._tab_widget.zoom_factor() * 1.5
if (new_zoom <= WebEngineView.maximum_zoom_factor()):
self._tab_widget.set_zoom_factor(new_zoom)
self._update_zoom_label()
def _zoom_out(self):
new_zoom = self._tab_widget.zoom_factor() / 1.5
if (new_zoom >= WebEngineView.minimum_zoom_factor()):
self._tab_widget.set_zoom_factor(new_zoom)
self._update_zoom_label()
def _reset_zoom(self):
self._tab_widget.set_zoom_factor(1)
self._update_zoom_label()
def _update_zoom_label(self):
percent = int(self._tab_widget.zoom_factor() * 100)
self._zoom_label.setText("{}%".format(percent))
def _download_requested(self, item):
# Remove old downloads before opening a new one
for old_download in self.statusBar().children():
if (type(old_download).__name__ == 'DownloadWidget'
and old_download.state() !=
QWebEngineDownloadItem.DownloadInProgress):
self.statusBar().removeWidget(old_download)
del old_download
item.accept()
download_widget = DownloadWidget(item)
download_widget.remove_requested.connect(
self._remove_download_requested, Qt.QueuedConnection)
self.statusBar().addWidget(download_widget)
def _remove_download_requested(self):
download_widget = self.sender()
self.statusBar().removeWidget(download_widget)
del download_widget
def _show_find(self):
if self._find_tool_bar is None:
self._find_tool_bar = FindToolBar()
self._find_tool_bar.find.connect(self._tab_widget.find)
self.addToolBar(Qt.BottomToolBarArea, self._find_tool_bar)
else:
self._find_tool_bar.show()
self._find_tool_bar.focus_find()
def write_bookmarks(self):
self._bookmark_widget.write_bookmarks()
