def __init__(self, page, parent=None):
super(HelpForm, self).__init__(parent)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setAttribute(Qt.WA_GroupLeader)
backAction = QAction(QIcon(":/back.png"), "&Back", self)
backAction.setShortcut(QKeySequence.Back)
homeAction = QAction(QIcon(":/home.png"), "&Home", self)
homeAction.setShortcut("Home")
self.pageLabel = QLabel()
toolBar = QToolBar()
toolBar.addAction(backAction)
toolBar.addAction(homeAction)
toolBar.addWidget(self.pageLabel)
self.textBrowser = QTextBrowser()
layout = QVBoxLayout()
layout.addWidget(toolBar)
layout.addWidget(self.textBrowser, 1)
self.setLayout(layout)
backAction.triggered.connect(self.tbackward)
homeAction.triggered.connect(self.thome)
self.textBrowser.sourceChanged.connect(self.updatePageTitle)
self.textBrowser.setSearchPaths([":/help"])
self.textBrowser.setSource(QUrl(page))
self.resize(400, 600)
self.setWindowTitle("{0} Help".format(QApplication.applicationName()))
def __init__(self):
super().__init__()
# Resolução do monitor.
screen_size = app.primaryScreen().geometry()
width = screen_size.width()
height = screen_size.height()
# Tamanho inicial da janela.
self.resize(int(width / 2), int(height / 2))
# Tamanho mínimo da janela.
self.setMinimumSize(int(width / 3), int(height / 3))
# Título da janela.
self.setWindowTitle('PySide2 QToolBar()')
# Ícone da janela principal
icon = QIcon()
icon.addPixmap(QPixmap('../../assets/icons/icon.png'))
self.setWindowIcon(icon)
# Toolbar pode ser movido para diversas áreas da janela.
tool_bar = QToolBar()
tool_bar.setToolTip('Barra de ferramentas')
self.addToolBar(tool_bar)
icon_copy = QIcon('../../assets/icons/copy-64x64.png')
tool_bar.addAction(icon_copy, 'Copiar',
self.action_copy).setToolTip('Copiar')
icon_paste = QIcon('../../assets/icons/paste-64x64.png')
tool_bar.addAction(icon_paste, 'Colar',
self.action_paste).setToolTip('Colar')
def add_actions(self, toolbar: QToolBar):
colorful_act = toolbar.addAction(QIcon("images/icons_colorful.png"),
"Colorful")
colorful_act.setCheckable(True)
colorful_act.setChecked(self.plot.colorful)
colorful_act.triggered.connect(
lambda checked: setattr(self.plot, "colorful", checked))
show_points_act = toolbar.addAction(
QIcon("images/icons_show_points.png"), "Points")
show_points_act.setCheckable(True)
show_points_act.setChecked(self.plot.show_points)
show_points_act.triggered.connect(
lambda checked: setattr(self.plot, "show_points", checked))
show_pen_up_act = toolbar.addAction(
QIcon("images/icons_show_pen_up.png"), "Pen-Up")
show_pen_up_act.setCheckable(True)
show_pen_up_act.setChecked(self.plot.show_pen_up)
show_pen_up_act.triggered.connect(
lambda checked: setattr(self.plot, "show_pen_up", checked))
show_axes_act = toolbar.addAction(QIcon("images/icons_show_axes.png"),
"Axes")
show_axes_act.setCheckable(True)
show_axes_act.setChecked(self.plot.show_axes)
show_axes_act.triggered.connect(
lambda checked: setattr(self.plot, "show_axes", checked))
scale = UnitComboBox()
scale.setCurrentText(self.plot.unit)
scale.currentTextChanged.connect(
lambda text: setattr(self.plot, "unit", text))
toolbar.addWidget(scale)
class FontColorButton(QPushButton):
""" Displays the currently selected color and provides an icon for indicating what is being colored """
def __init__(self, icon: QIcon, s: str):
super().__init__()
self._lo = QHBoxLayout()
self._filler = QToolBar()
self._filler.addAction(icon, s)
self._filler.setMaximumHeight(25)
self._filler.setMaximumWidth(25)
self._filler.setStyleSheet("""
QWidget {
border: 0px
}
""")
self._filler.actionTriggered.connect(lambda _: self.pressed.emit())
self._lo.addWidget(self._filler)
self._lo.setSpacing(0)
self.setMaximumWidth(40)
self._color_display = QLabel("")
self._color_display.setMinimumWidth(8)
self._lo.addWidget(self._color_display)
self.setLayout(self._lo)
self._lo.setMargin(3)
def set_color_display(self, color: QColor):
self._color_display.setStyleSheet(
"border-radius: 2px; background-color: {};".format(color.name()))
def __init__(self, parent=None):
"""Class constructor.
Args:
parent (QWidget): the widget's parent
"""
super().__init__(parent)
self.option = QStyleOptionMenuItem()
zoom_action = QAction("Zoom")
QMenu(parent).initStyleOption(self.option, zoom_action)
layout = QHBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
tool_bar = QToolBar(self)
tool_bar.setFixedHeight(self.option.rect.height())
minus_action = tool_bar.addAction("-")
reset_action = tool_bar.addAction("Reset")
plus_action = tool_bar.addAction("+")
layout.addSpacing(self.option.rect.width())
layout.addWidget(tool_bar)
minus_action.setToolTip("Zoom out")
reset_action.setToolTip("Reset zoom")
plus_action.setToolTip("Zoom in")
minus_action.triggered.connect(lambda x: self.minus_pressed.emit())
plus_action.triggered.connect(lambda x: self.plus_pressed.emit())
reset_action.triggered.connect(lambda x: self.reset_pressed.emit())
def __init__(self):
super().__init__()
self.setWindowTitle("My App")
label = QLabel("Hello!")
label.setAlignment(Qt.AlignCenter)
self.setCentralWidget(label)
toolbar = QToolBar("My main toolbar")
toolbar.setIconSize(QSize(16, 16))
self.addToolBar(toolbar)
button_action = QAction(QIcon("bug.png"), "Your button", self)
button_action.setStatusTip("This is your button")
button_action.triggered.connect(self.onMyToolBarButtonClick)
button_action.setCheckable(True)
toolbar.addAction(button_action)
toolbar.addSeparator()
button_action2 = QAction(QIcon("bug.png"), "Your button2", self)
button_action2.setStatusTip("This is your button2")
button_action2.triggered.connect(self.onMyToolBarButtonClick)
button_action2.setCheckable(True)
toolbar.addAction(button_action2)
toolbar.addWidget(QLabel("Hello"))
toolbar.addWidget(QCheckBox())
self.setStatusBar(QStatusBar(self))
def create_and_add_toolbar_action(
icon_path: str,
mouse_over_text: str,
trigger_method: Callable,
component_tool_bar: QToolBar,
component_tree_view_tab: QWidget,
set_enabled: bool = False,
) -> QAction:
"""
Create a QAction and add it to the component toolbar.
:param icon_path: The location of the action icon relative to the "ui" folder.
:param mouse_over_text: The text that should appear when the mouse is above the icon.
:param trigger_method: The method that should be called when the icon is clicked.
:param component_tool_bar: The tool bad that the action is added to.
:param component_tree_view_tab: The tab for the component tree view.
:param set_enabled: A bool indicating whether or not the action should be enabled immediately after it's been
created. Only needs to be true for the Add Component button.
:return The new QAction.
"""
toolbar_action = QAction(
QIcon(os.path.join(root_dir, "ui", icon_path)),
mouse_over_text,
component_tree_view_tab,
)
toolbar_action.triggered.connect(trigger_method)
component_tool_bar.addAction(toolbar_action)
set_enabled_and_raise(toolbar_action, set_enabled)
return toolbar_action
def createToolBar(self):
"""
Criar barra de ferramentas
"""
tool_bar = QToolBar("Barra de Ferramentas")
tool_bar.setIconSize(QSize(16, 16))
self.addToolBar(tool_bar)
tool_bar.addAction(self.sair_act)
def __init__(self):
super().__init__()
self.__ui = Ui_MainWindow()
self.__ui.setupUi(self)
self.__ui.action_Exit.triggered.connect(self.exit)
toolBar = QToolBar()
self.addToolBar(Qt.LeftToolBarArea, toolBar)
toolBar.addAction(self.__ui.action_Exit)
def testReference(self):
toolbar = QToolBar()
for i in xrange(20):
toolbar.addAction(QAction("Action %d" % i, None))
buttons = toolbar.findChildren(QToolButton, "")
toolbar.clear()
for b in buttons:
self.assertRaises(RuntimeError, b.objectName)
def testReference(self):
toolbar = QToolBar()
for i in xrange(20):
toolbar.addAction(QAction("Action %d" % i, None))
buttons = toolbar.findChildren(QToolButton, "")
toolbar.clear()
for b in buttons:
self.assertRaises(RuntimeError, b.objectName)
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("PySide2 Camera Example (" + name + ")")
self.statusBar().showMessage("Starting: '" + name + "'", 5000)
self.camera.start()
else:
self.setWindowTitle("PySide2 Camera Example")
self.takePictureAction.setEnabled(False)
self.statusBar().showMessage("Camera unavailable", 5000)
def __init__(self):
super().__init__()
self.setWindowTitle("My App")
label = QLabel("Hello!")
# The `Qt` namespace has a lot of attributes to customize
# widgets. See: http://doc.qt.io/qt-5/qt.html
label.setAlignment(Qt.AlignCenter)
# Set the central widget of the Window. Widget will expand
# to take up all the space in the window by default.
self.setCentralWidget(label)
toolbar = QToolBar("My main toolbar")
toolbar.setIconSize(QSize(16, 16))
self.addToolBar(toolbar)
button_action = QAction(QIcon("bug.png"), "&Your button", self)
button_action.setStatusTip("This is your button")
button_action.triggered.connect(self.onMyToolBarButtonClick)
button_action.setCheckable(True)
# You can enter keyboard shortcuts using key names (e.g. Ctrl+p)
# Qt.namespace identifiers (e.g. Qt.CTRL + Qt.Key_P)
# or system agnostic identifiers (e.g. QKeySequence.Print)
button_action.setShortcut(QKeySequence("Ctrl+p"))
toolbar.addAction(button_action)
toolbar.addSeparator()
button_action2 = QAction(QIcon("bug.png"), "Your &button2", self)
button_action2.setStatusTip("This is your button2")
button_action2.triggered.connect(self.onMyToolBarButtonClick)
button_action2.setCheckable(True)
toolbar.addAction(button_action)
toolbar.addWidget(QLabel("Hello"))
toolbar.addWidget(QCheckBox())
self.setStatusBar(QStatusBar(self))
menu = self.menuBar()
file_menu = menu.addMenu("&File")
file_menu.addAction(button_action)
file_menu.addSeparator()
file_submenu = file_menu.addMenu("Submenu")
file_submenu.addAction(button_action2)
class Main(QMainWindow):
""" MainWindow which contains all widgets of POSM.
"""
def __init__(self, parent=None):
super(Main, self).__init__(parent)
self.setWindowTitle("POSM")
# All widgets should be destryed when the main window is closed. This the widgets can use the destroyed widget
# to allow clean up. E.g. save the database of the TileLoader.
self.setAttribute(QtCore.Qt.WA_DeleteOnClose, True)
self.resize(config.config.window_size[0], config.config.window_size[1])
self.elements_loader = ElementsLoader()
# Element Viewer as DockWidget
self.element_viewer = ElementViewer(self)
self.dock_element_viewer = QDockWidget()
self.dock_element_viewer.setWindowTitle("Element Viewer")
self.dock_element_viewer.setFeatures(QDockWidget.DockWidgetFloatable
| QDockWidget.DockWidgetMovable)
self.dock_element_viewer.setWidget(self.element_viewer)
self.addDockWidget(QtCore.Qt.RightDockWidgetArea,
self.dock_element_viewer)
# LayerManger as DockWidget
self.layer_manager = LayerManager(self)
self.dock_layer_manager = QDockWidget()
self.dock_layer_manager.setWindowTitle("Layer Manager")
self.dock_layer_manager.setFeatures(QDockWidget.DockWidgetFloatable
| QDockWidget.DockWidgetMovable)
self.dock_layer_manager.setWidget(self.layer_manager)
self.addDockWidget(QtCore.Qt.RightDockWidgetArea,
self.dock_layer_manager)
self.viewer = Viewer.Viewer(self)
self.setCentralWidget(self.viewer)
self.viewer.setFocus()
self.viewer.setFocusPolicy(QtCore.Qt.StrongFocus)
self.changeset = Changeset(self)
self.changset_form = ChangesetForm(self)
self.toolbar = QToolBar()
self.toolbar.addAction("Load Elements", self.viewer.load_elements)
self.toolbar.addAction("Undo Changes", self.viewer.undo_changes)
self.toolbar.addAction("Create Node",
partial(self.viewer.change_mode, "new_node"))
self.toolbar.addAction("Upload Changes", self.changset_form.show)
self.toolbar.addAction("Open Configuration",
partial(os.startfile, str(config.path_config)))
self.addToolBar(self.toolbar)
self.statusBar().showMessage("Welcome to POSM!")
def _add_tool_bar_items(
tool_bar: QToolBar,
items: List[Union[str, QAction]],
) -> None:
for item in items:
if item == _TOOL_BAR_SEPARATOR:
tool_bar.addSeparator()
elif item == _TOOL_BAR_SPACER:
spacer = QWidget(tool_bar)
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
tool_bar.addWidget(spacer)
elif isinstance(item, QAction):
tool_bar.addAction(item)
def _construct_layout(self):
""" Construct the widget layout for the exchanges parameters tab
"""
layout = QVBoxLayout()
row = QToolBar()
row.addWidget(header("Complete parameters overview "))
row.setIconSize(QSize(24, 24))
row.addAction(qicons.question, "About parameters overview",
self.explanation)
layout.addWidget(row)
layout.addWidget(horizontal_line())
layout.addWidget(self.table, 2)
layout.addStretch(1)
self.setLayout(layout)
def __init__(self, figsize=(14, 10)):
self.figure = Figure(figsize=figsize)
self.figure.tight_layout()
self.logger = logging.getLogger('curvfig')
self.curves_artists: OrderedDict[WdCurve,
Mapping[str, Any]] = OrderedDict()
# fig.subplots_adjust(left=0, bottom=0.001, right=1, top=1, wspace=None, hspace=None)
super().__init__(self.figure)
toolbar = NavigationToolbar(self, self)
toolbar.setOrientation(Qt.Vertical)
toolbar.setIconSize(QSize(15, 15))
toolbar2 = QToolBar()
toolbar2.setOrientation(Qt.Vertical)
toolbar2.addAction("x")
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("PySide2 Camera Example (" + name + ")")
self.statusBar().showMessage("Starting: '" + name + "'", 5000)
self.camera.start()
else:
self.setWindowTitle("PySide2 Camera Example")
self.takePictureAction.setEnabled(False)
self.statusBar().showMessage("Camera unavailable", 5000)
def testAddActionWithIcon(self):
bar = QToolBar()
self._called = False
icon = QIcon()
a = bar.addAction(icon, "act1", self.callback)
a.trigger()
self.assert_(self._called)
def _create_empty_widget(self, ) -> QWidget:
toolbar = QToolBar(self)
toolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
spacer_begin = QWidget(toolbar)
spacer_begin.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Preferred)
spacer_end = QWidget(toolbar)
spacer_end.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
toolbar.addWidget(spacer_begin)
toolbar.addAction(self._action_new)
toolbar.addAction(self._action_open)
toolbar.addWidget(spacer_end)
return toolbar
def testAddActionWithIcon(self):
bar = QToolBar()
self._called = False
icon = QIcon()
a = bar.addAction(icon, "act1", self.callback)
a.trigger()
self.assertTrue(self._called)
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().__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)
def demo_docking_widgets():
"""
Demonstrates how to create a QWidget with PySide2 and attach it to the 3dsmax main window.
Creates two types of dockable widgets, a QDockWidget and a QToolbar
"""
# Retrieve 3ds Max Main Window QWdiget
main_window = GetQMaxMainWindow()
# QAction reused by both dockable widgets.
cylinder_icon_path = os.path.dirname(os.path.realpath(__file__)) + "\\cylinder_icon_48.png"
cylinder_icon = QtGui.QIcon(cylinder_icon_path)
create_cyl_action = QAction(cylinder_icon, u"Create Cylinder", main_window)
create_cyl_action.triggered.connect(create_cylinder)
# QDockWidget construction and placement over the main window
dock_widget = QDockWidget(main_window)
# Set for position persistence
dock_widget.setObjectName("Creators")
# Set to see dock widget name in toolbar customize popup
dock_widget.setWindowTitle("Creators")
dock_tool_button = QToolButton()
dock_tool_button.setAutoRaise(True)
dock_tool_button.setDefaultAction(create_cyl_action)
dock_tool_button.setToolButtonStyle(QtCore.Qt.ToolButtonTextOnly)
dock_widget.setWidget(dock_tool_button)
main_window.addDockWidget(QtCore.Qt.LeftDockWidgetArea, dock_widget)
dock_widget.setFloating(True)
dock_widget.show()
# QToolBar construction and attachement to main window
toolbar_widget = QToolBar(main_window)
# Set for position persistence
toolbar_widget.setObjectName("Creators TB")
# Set to see dock widget name in toolbar customize popup
toolbar_widget.setWindowTitle("Creators TB")
toolbar_widget.setFloatable(True)
toolbar_widget.addAction(create_cyl_action)
main_window.addToolBar(QtCore.Qt.BottomToolBarArea, toolbar_widget)
toolbar_widget.show()
toolbar_position = get_pos_to_dock_toolbar(dock_widget)
make_toolbar_floating(toolbar_widget, toolbar_position)
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, *args, **kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
self.available_cameras = QCameraInfo.availableCameras()
if not self.available_cameras:
pass #quit
self.status = QStatusBar()
self.setStatusBar(self.status)
self.save_path = ""
self.viewfinder = QCameraViewfinder()
self.viewfinder.show()
self.setCentralWidget(self.viewfinder)
# Set the default camera.
self.select_camera(0)
# Setup tools
camera_toolbar = QToolBar("Camera")
camera_toolbar.setIconSize(QSize(14, 14))
self.addToolBar(camera_toolbar)
photo_action = QAction(QIcon(os.path.join('images', 'camera-black.png')), "Take photo...", self)
photo_action.setStatusTip("Take photo of current view")
photo_action.triggered.connect(self.take_photo)
camera_toolbar.addAction(photo_action)
change_folder_action = QAction(QIcon(os.path.join('images', 'blue-folder-horizontal-open.png')), "Change save location...", self)
change_folder_action.setStatusTip("Change folder where photos are saved.")
change_folder_action.triggered.connect(self.change_folder)
camera_toolbar.addAction(change_folder_action)
camera_selector = QComboBox()
camera_selector.addItems([c.description() for c in self.available_cameras])
camera_selector.currentIndexChanged.connect( self.select_camera )
camera_toolbar.addWidget(camera_selector)
self.setWindowTitle("NSAViewer")
self.show()
def testToolBar(self):
self._actionDestroyed = False
w = QWidget()
toolBar = QToolBar(w)
act = toolBar.addAction("MENU")
_ref = weakref.ref(act, self.actionDestroyed)
act = None
self.assertFalse(self._actionDestroyed)
toolBar.clear()
self.assertTrue(self._actionDestroyed)
def testToolBar(self):
self._actionDestroyed = False
w = QWidget()
toolBar = QToolBar(w)
act = toolBar.addAction("MENU")
_ref = weakref.ref(act, self.actionDestroyed)
act = None
self.assertFalse(self._actionDestroyed)
toolBar.clear()
self.assertTrue(self._actionDestroyed)
class MainWindow(QWidget):
def __init__(self, parent=None):
super().__init__(parent)
self.setWindowTitle("AxiGUI")
self._config_dialog = ConfigDialog()
self._plot_control = PlotControlWidget()
# setup toolbar
self._toolbar = QToolBar()
self._toolbar.setIconSize(QSize(64, 64))
load_act = self._toolbar.addAction(QIcon("images/icons_open.png"),
"Load")
load_act.triggered.connect(lambda: self.load_svg())
config_act = self._toolbar.addAction(
QIcon("images/icons_settings.png"), "Config")
config_act.triggered.connect(lambda: self._config_dialog.exec_())
self._toolbar.addSeparator()
self._plot_control.add_actions(self._toolbar)
empty = QWidget()
empty.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred))
self._toolbar.addWidget(empty)
quit_act = self._toolbar.addAction(QIcon("images/icons_exit.png"),
"Quit")
quit_act.triggered.connect(lambda: QCoreApplication.quit())
# setup layout
layout = QVBoxLayout()
layout.setSpacing(0)
layout.setMargin(0)
layout.addWidget(self._toolbar)
layout.addWidget(self._plot_control)
self.setLayout(layout)
def load_svg(self):
# TODO: remember last folder opened in the session
path = QFileDialog.getOpenFileName(self, "Choose SVG file:",
"/Users/hhip/Drive/axidraw",
"SVG (*.svg)")
if path[0]:
self._plot_control.load_svg(path[0])
def _construct_layout(self):
layout = QVBoxLayout()
row = QToolBar()
row.addWidget(header("Parameter Scenarios"))
row.addAction(qicons.question, "About parameters scenarios",
self.explanation)
layout.addWidget(row)
layout.addWidget(horizontal_line())
row = QHBoxLayout()
row.addWidget(self.save_btn)
row.addWidget(self.load_btn)
row.addWidget(self.calculate_btn)
row.addWidget(self.hide_group)
row.addStretch(1)
layout.addLayout(row)
layout.addWidget(self.tbl)
layout.addStretch(1)
self.setLayout(layout)
def qtoolbar(self):
toolbar = QToolBar(self.name, self.window)
for action in self.actions:
if isinstance(action, ToolbarSplitter):
toolbar.addSeparator()
else:
if action.icon is not None:
act = QAction(action.icon, action.name, toolbar)
else:
act = QAction(action.name, toolbar)
if action.triggered is not None:
act.triggered.connect(action.triggered)
if action.tooltip:
act.setToolTip(action.tooltip)
toolbar.addAction(act)
toolbar.setIconSize(QSize(16, 16))
return toolbar
class Ui_FE14ChapterEditor(QMainWindow):
def __init__(self, parent=None):
super().__init__(parent)
self.toolbar = QToolBar()
self.addToolBar(self.toolbar)
self.add_chapter_action = QAction("Add Chapter")
self.hide_selector_action = QAction("Toggle Selection Pane")
self.toolbar.addAction(self.add_chapter_action)
self.toolbar.addSeparator()
self.toolbar.addAction(self.hide_selector_action)
self.selector_layout = QVBoxLayout()
self.chapter_search_bar = QLineEdit()
self.chapter_search_bar.setPlaceholderText("Search...")
self.chapter_list_view = QListView()
self.selector_layout.addWidget(self.chapter_search_bar)
self.selector_layout.addWidget(self.chapter_list_view)
self.selector_widget = QWidget()
self.selector_widget.setLayout(self.selector_layout)
self.selector_widget.setFixedWidth(225)
self.config_tab = FE14ChapterConfigTab()
self.map_tab = FE14MapEditor()
self.characters_tab = FE14CharacterEditor(is_person=True)
self.conversation_tab = FE14ConversationEditor()
self.tab_widget = QTabWidget()
self.tab_widget.addTab(self.config_tab, "Config")
self.tab_widget.addTab(self.map_tab, "Map")
self.tab_widget.addTab(self.characters_tab, "Characters")
self.tab_widget.addTab(self.conversation_tab, "Text")
self.main_layout = QHBoxLayout()
self.main_widget = QWidget()
self.visual_splitter = QFrame()
self.visual_splitter.setFrameShape(QFrame.VLine)
self.visual_splitter.setFrameShadow(QFrame.Sunken)
self.main_widget.setLayout(self.main_layout)
self.main_layout.addWidget(self.selector_widget)
self.main_layout.addWidget(self.visual_splitter)
self.main_layout.addWidget(self.tab_widget)
self.setCentralWidget(self.main_widget)
def _construct_layout(self):
""" Construct the widget layout for the variable parameters tab
"""
layout = QVBoxLayout()
self.uncertainty_columns.setChecked(False)
row = QToolBar()
row.addWidget(header("Parameters "))
row.addWidget(self.show_database_params)
row.addWidget(self.uncertainty_columns)
row.addAction(
qicons.question, "About brightway parameters",
self.explanation
)
layout.addWidget(row)
layout.addWidget(horizontal_line())
row = QHBoxLayout()
row.addWidget(header("Project:"))
row.addWidget(self.new_project_param)
row.addStretch(1)
layout.addLayout(row)
layout.addWidget(self.project_table)
row = QHBoxLayout()
row.addWidget(self.database_header)
row.addWidget(self.new_database_param)
row.addStretch(1)
layout.addLayout(row)
layout.addWidget(self.database_table)
row = QHBoxLayout()
row.addWidget(header("Activity:"))
row.addWidget(self.show_order)
row.addStretch(1)
layout.addLayout(row)
layout.addWidget(self.activity_table)
layout.addStretch(1)
self.setLayout(layout)
class ArrayDatasetTableWidget(QWidget):
"""
Wrapper over a QTableView with buttons to add and delete rows/columns
"""
def __init__(self, type: np.dtype = np.byte, parent=None):
super().__init__(parent)
self.model = ArrayDatasetTableModel(dtype=type, parent=self)
self.view = QTableView()
self.view.setModel(self.model)
self.view.setSelectionMode(QAbstractItemView.SingleSelection)
self.view.setItemDelegate(ValueDelegate(type, parent))
self.setLayout(QGridLayout())
self.toolbox = QToolBar()
self.add_row_button = QAction(text="➕ Add Row")
self.add_row_button.triggered.connect(self.model.add_row)
self.remove_row_button = QAction(text="➖ Remove Row")
self.remove_row_button.triggered.connect(
partial(self.model.delete_index, True))
self.add_column_button = QAction(text="➕ Add Column")
self.add_column_button.triggered.connect(self.model.add_column)
self.remove_column_button = QAction(text="➖ Remove Column")
self.remove_column_button.triggered.connect(
partial(self.model.delete_index, False))
self.toolbox.addAction(self.add_row_button)
self.toolbox.addAction(self.remove_row_button)
self.toolbox.addAction(self.add_column_button)
self.toolbox.addAction(self.remove_column_button)
self.layout().addWidget(self.toolbox)
self.layout().addWidget(self.view)
def toolbar(self):
toolbar = QToolBar("My main toolbar")
toolbar.setIconSize(QSize(16, 16))
self.addToolBar(toolbar)
mouse = QAction(QIcon('./icons/icons-01.png'),
'mouse',
self,
checkable=True)
mouse.setStatusTip('mouse')
mouse.triggered.connect(lambda: self.set_pointer('mouse'))
square = QAction(QIcon('./icons/icons_Square.png'),
'square',
self,
checkable=True)
square.setStatusTip('square')
square.triggered.connect(lambda: self.set_pointer('square'))
circle = QAction(QIcon('./icons_Circle.png'),
'circle',
self,
checkable=True)
circle.setStatusTip('circle')
circle.triggered.connect(lambda: self.set_pointer('circle'))
crosshair = QAction(QIcon('./icons/icons_Crosshair.png'),
'crosshair',
self,
checkable=True)
crosshair.setStatusTip('crosshair')
crosshair.triggered.connect(lambda: self.set_pointer('cross'))
brush = QAction(QIcon('./icons/icons_Brush.png'),
'brush',
self,
checkable=True)
brush.setStatusTip('crosshair')
brush.triggered.connect(lambda: self.set_pointer('brush'))
group = QActionGroup(self, exclusive=True)
for action in (mouse, square, circle, crosshair, brush):
toolbar.addAction(action)
group.addAction(action)
annotations = QAction(QIcon('./icons/icons_Circle.png'),
'Annot',
self,
checkable=True)
annotations.setStatusTip('Toggle annotations')
annotations.triggered.connect(self.toggel_annot)
toolbar.addAction(annotations)
clear = QAction(QIcon('./icons/icons_Square.png'), 'Clear', self)
clear.setStatusTip('Clear annotations')
clear.triggered.connect(self.clear_annot)
toolbar.addAction(clear)
self.setStatusBar(QStatusBar(self))
class AddActionText(UsesQApplication):
'''Test case for calling QToolbar.addAction passing a text'''
def setUp(self):
#Acquire resources
super(AddActionText, self).setUp()
self.window = QMainWindow()
self.toolbar = QToolBar()
self.window.addToolBar(self.toolbar)
def tearDown(self):
#Release resources
super(AddActionText, self).tearDown()
del self.toolbar
del self.window
def testText(self):
#QToolBar.addAction(text) - add a QToolButton
self.toolbar.addAction('aaaa')
self.assertEqual(len(self.toolbar.actions()), 1)
action = self.toolbar.actions()[0]
self.assert_(isinstance(action, QAction))
self.assertEqual(action.text(), 'aaaa')
def testAddAction(self):
bar = QToolBar()
self._called = False
a = bar.addAction("act1", self.callback)
a.trigger()
self.assert_(self._called)
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('PySide2 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)
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__ == 'download_widget' and \
old_download.state() != QWebEngineDownloadItem.DownloadInProgress:
self.statusBar().removeWidget(old_download)
del old_download
item.accept()
download_widget = download_widget(item)
download_widget.removeRequested.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()
