def createLayout(self):
self.groupBox = QGroupBox("What Is Your Favorite Sport?")
hboxlayout = QHBoxLayout()
self.button = QPushButton("Football", self)
self.button.setIcon(QtGui.QIcon("home.png"))
self.button.setIconSize(QSize(40, 40))
self.button.setToolTip("This Is Click Me Button")
self.button.setMinimumHeight(40)
hboxlayout.addWidget(self.button)
self.button1 = QPushButton("Cricket", self)
self.button1.setIcon(QtGui.QIcon("home.png"))
self.button1.setIconSize(QSize(40, 40))
self.button1.setMinimumHeight(40)
self.button1.setToolTip("This Is Click Me Button")
hboxlayout.addWidget(self.button1)
self.button2 = QPushButton("Tennis", self)
self.button2.setIcon(QtGui.QIcon("home.png"))
self.button2.setIconSize(QSize(40, 40))
self.button2.setMinimumHeight(40)
self.button2.setToolTip("This Is Click Me Button")
hboxlayout.addWidget(self.button2)
self.groupBox.setLayout(hboxlayout)
def minimumSize(self):
size = QSize()
for item in self.itemList:
size = size.expandedTo(item.minimumSize())
size += QSize(2 * self.getContentsMargins()[0],
2 * self.getContentsMargins()[0])
return size
def add_header_fields(self) -> None:
layout: QLayout = QHBoxLayout()
self.layout().addItem(layout)
labels_layout: QLayout = QVBoxLayout()
line_edits_layout: QLayout = QVBoxLayout()
layout.addItem(labels_layout)
layout.addItem(line_edits_layout)
labels_layout.addWidget(QLabel("""Header File Name""", self))
labels_layout.addWidget(
QLabel("""Output Path (relative to root of project)""", self))
line_edits_layout.addWidget(self.header_name_input)
path_edit_layout: QLayout = QHBoxLayout()
path_edit_layout.addWidget(self.header_output_path_input)
path_edit_layout.addWidget(self.header_output_path_selector)
path_edit_layout.setAlignment(self.header_output_path_selector,
Qt.AlignmentFlag.AlignRight)
self.header_output_path_selector.setFixedSize(QSize(25, 25))
line_edits_layout.addItem(path_edit_layout)
self.header_output_path_selector.clicked.connect(
lambda: self.open_path_selection_dialog())
def __init__(self, parent=None):
QListView.__init__(self, parent)
self.setStyleSheet('''
QListView { color: FG; background: BG }
QListView::item:selected { border-radius: 8px; background: HB; color: HF }
'''.replace('HB',
color('tab tree current background',
'palette(highlight)')).replace(
'HF',
color('tab tree current foreground',
'palette(highlight-text')).replace(
'FG',
color('tab tree foreground',
'palette(window-text)')).replace(
'BG',
color(
'tab tree background',
'palette(window)')))
self.setFrameStyle(QFrame.Shape.NoFrame)
self.viewport().setAutoFillBackground(False)
self.setIconSize(QSize(16, 16))
self.setSpacing(2)
self.setFocusPolicy(Qt.FocusPolicy.NoFocus)
self.delegate = d = Delegate(self)
self.setItemDelegate(d)
def setup_ui(self):
self.setObjectName("Dialog")
self.resize(497, 235)
self.gridLayout = l = QGridLayout(self)
l.setObjectName("gridLayout")
self.icon_label = la = QLabel('')
la.setMaximumSize(QSize(68, 68))
la.setScaledContents(False)
la.setObjectName("icon_label")
l.addWidget(la)
self.msg = la = QLabel(self)
la.setWordWrap(True), la.setMinimumWidth(400)
la.setOpenExternalLinks(True)
la.setObjectName("msg")
l.addWidget(la, 0, 1, 1, 1)
self.det_msg = dm = QPlainTextEdit(self)
dm.setReadOnly(True)
dm.setObjectName("det_msg")
l.addWidget(dm, 1, 0, 1, 2)
self.bb = bb = QDialogButtonBox(self)
bb.setStandardButtons(QDialogButtonBox.StandardButton.Ok)
bb.setObjectName("bb")
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
l.addWidget(bb, 3, 0, 1, 2)
self.toggle_checkbox = tc = QCheckBox(self)
tc.setObjectName("toggle_checkbox")
l.addWidget(tc, 2, 0, 1, 2)
def UiComponents(self):
button = QPushButton("Close Window", self)
button.setGeometry(QRect(100, 100, 111, 50))
button.setIcon(QtGui.QIcon("home.png"))
button.setIconSize(QSize(40, 40))
button.setToolTip("This Is Click Me Button")
button.clicked.connect(ClickMe)
def __init__(self, game, boardrect, parent=None):
super().__init__(parent)
self.game = game
self.boardrect = boardrect
margin_size = self.boardrect.x()
self.__answerbarrect = boardrect.adjusted(-ANSWERBARS, 0, ANSWERBARS,
0)
self.__correctrect = QRect(0, 0, margin_size, self.boardrect.height())
self.__incorrectrect = QRect(self.boardrect.right(), 0, margin_size,
self.boardrect.height())
arrow_size = QSize(int(margin_size * 0.7), int(margin_size * 0.7))
self.__leftarrowrect = QRect(QPoint(0, 0), arrow_size)
self.__leftarrowrect.moveCenter(self.__correctrect.center())
self.__rightarrowrect = QRect(QPoint(0, 0), arrow_size)
self.__rightarrowrect.moveCenter(self.__incorrectrect.center())
self.__leftarrowimage = QPixmap(resource_path("left-arrow.png"))
self.__rightarrowimage = QPixmap(resource_path("right-arrow.png"))
self.__spaceimage = QPixmap(resource_path("space.png"))
self.show()
self.__lit = False
self.arrowhints = False
self.spacehints = False
def createToolbar(self):
"""Create the application's toolbar for playing GIFs."""
toolbar = self.addToolBar("GIF Controls Toolbar")
toolbar.setIconSize(QSize(24, 24))
# Add actions to the toolbar
toolbar.addAction(self.play_act)
toolbar.addAction(self.pause_act)
toolbar.addAction(self.stop_act)
def mousePressEvent(self, event):
"""Handle mouse press event."""
self.origin = event.pos()
if not (self.rubber_band):
self.rubber_band = QRubberBand(QRubberBand.Rectangle, self)
self.rubber_band.setGeometry(QRect(self.origin, QSize()))
self.rubber_band.show()
#print(self.rubber_band.height())
print(self.rubber_band.x())
def getInitialSettings(self):
"""Get initial settings of the application using QSettings upon startup."""
position = self.settings.value("position", QPoint(200, 0))
size = self.settings.value("size", QSize(800, 500))
self.is_delete_checked = self.settings.value("delete_images", type=bool)
# restoreState() is used here to restore the image_preview_dock widget
self.restoreState(self.settings.value("window_state", bytes(QByteArray())))
self.resize(size)
self.move(position)
return self.is_delete_checked
def __init__(self):
super().__init__()
self.app = QApplication.instance()
self.setWindowTitle(gbl.title)
self.setMinimumSize(QSize(1000, 400))
self.minesite_changed.connect(self.update_minesite_label)
self.minesite_label = QLabel(
self
) # permanent label for status bar so it isnt changed by statusTips
self.minesite_label.setToolTip(
'Global MineSite > Set with [Ctrl + Shift + M]')
self.rows_label = QLabel(self)
self.statusBar().addPermanentWidget(self.rows_label)
self.statusBar().addPermanentWidget(self.minesite_label)
# Settings
s = QSettings('sms', 'smseventlog', self)
screen_point = s.value('window position', False)
screen_size = s.value('window size', False)
# if screen size/left anchor pt values are not set or out of range, use default
if not (screen_point and screen_size
and gbl.check_screen_point(screen_point)):
screen_point = QPoint(50, 50)
screen_size = QSize(1200, 1000)
# move/resize MainWindow to last position/size
self.resize(screen_size)
self.move(screen_point)
self.settings = s
self.menus = {}
self.create_actions()
self.tabs = TabWidget(self)
self.setCentralWidget(self.tabs)
self.update_minesite_label()
self.threadpool = QThreadPool(self)
log.debug('Mainwindow init finished.')
def resizeEvent(self, a0: QResizeEvent) -> None:
if self.__keepAspectRatio:
# Force the widget to rezise with a 1:1 aspect ratio
# first calculate the smallest size axis:
smallestAxisSize = min(a0.size().width(), a0.size().height())
# set a newSize var with this as both the axes sizes
newSize = QSize(smallestAxisSize, smallestAxisSize)
# resize with this new 1:1 size
self.resize(newSize)
# force resizeEvent of super with implicitly modified resize
return super().resizeEvent(a0)
def add_header_row(self, _header: Header = Header()):
self.mock_env_cors_headers.insertRow(
self.mock_env_cors_headers.rowCount())
row_position = self.mock_env_cors_headers.rowCount()
self.mock_env_cors_headers.setItem(row_position - 1, 0,
QTableWidgetItem(_header.key))
self.mock_env_cors_headers.setItem(row_position - 1, 1,
QTableWidgetItem(_header.value))
_delete = QTableWidgetItem()
_delete_icon = QIcon(full_path("assets/images/icons/close.ico"))
_delete.setSizeHint(QSize(50, 50))
_delete.setIcon(_delete_icon)
self.mock_env_cors_headers.setItem(row_position - 1, 2, _delete)
def createListItems(self, image_path, item_name, image_info, new_name=None):
"""Simple method for creating QListWidgetItem objects.
'image_path': the path to the file.
'item_name': the base name used for QListWidgetItem objects.
'image_info': the QFileInfo object.
'new_name': used when importing new photos, making sure the program
points to the new image location."""
list_item = QListWidgetItem(QIcon(image_path), item_name)
self.image_view_lw.setIconSize(QSize(80, 80))
self.image_view_lw.addItem(list_item)
if new_name != None:
image_info.setFile(new_name)
self.image_view_lw.images_info_list.append(image_info)
def __init__(self, parent):
"""Subclassed QListWidget that displays images"""
super().__init__(parent)
self.parent = parent
self.setViewMode(QListView.ViewMode.IconMode)
self.setTextElideMode(Qt.TextElideMode.ElideMiddle)
self.setResizeMode(QListView.ResizeMode.Adjust)
self.setGridSize(QSize(110, 110))
self.setLayoutMode(QListView.LayoutMode.Batched)
self.setBatchSize(20) # Default is 100
# Methods handling item selection and drag/drop
self.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
self.setDragDropMode(QAbstractItemView.DragDropMode.NoDragDrop)
def _dialog_handler(self, _widget: QWidget):
_dialog = QDialog(self)
_widget.saved.connect(_dialog.close)
_widget.canceled.connect(_dialog.close)
_layout = QVBoxLayout()
_layout.setContentsMargins(0, 0, 0, 0)
_layout.addWidget(_widget)
_dialog.setWindowModality(Qt.WindowModality.WindowModal)
_dialog.setLayout(_layout)
_parent_size = self.sizeHint()
_modal_size = QSize(_parent_size.width() - 100,
_parent_size.height() - 100)
_dialog.setFixedSize(_modal_size)
_dialog.show()
def __init__(self, fontsize, parent=None):
super().__init__(parent)
self.fontsize = fontsize
cls = type(self)
if not cls.loading_movie:
cls.loading_movie = QMovie(resource_path("loading.gif"))
cls.loading_movie.setScaledSize(QSize(MOVIEWIDTH, MOVIEWIDTH))
cls.loading_movie.start()
# self.player_heading.setGeometry(0, 140, self.rect().width(), 50)
# self.player_heading.setAlignment(Qt.AlignmentFlag.AlignHCenter)
f = self.font()
f.setPointSize(self.fontsize)
self.setFont(f)
self.setAutoFillBackground(True)
self.setMovie(cls.loading_movie)
self.blink_timer = None
def insert_new_item(self, bypass_save_enable=False) -> None:
self.warning_updates_disabled = True
self.warnings_table.removeRow(self.warnings_table.rowCount() - 1)
self.warnings_table.setRowCount(self.warnings_table.rowCount() + 1)
button = QPushButton("-", self)
button.setFixedSize(QSize(25, 25))
row: int = self.warnings_table.rowCount() - 1
self.warnings_table.setCellWidget(row, 0, button)
button.clicked.connect(lambda: self.remove_table_row(row))
self.insert_helper_item()
self.warnings.append({i: '' for i in self.header_list if i})
self.warning_updates_disabled = False
self.check_for_save_update()
def update_table_items(self, bypass_save_enable=False) -> None:
self.__warnings_table.clearContents()
self.__warnings_table.setRowCount(len(self.warnings))
for i in range(len(self.warnings)):
for header in self.header_list:
if len(header) == 0:
button = QPushButton("-", self)
button.setFixedSize(QSize(25, 25))
self.warnings_table.setCellWidget(i, 0, button)
button.clicked.connect(lambda: self.remove_table_row(i))
continue
item: QTableWidgetItem = QTableWidgetItem()
item.setText(self.warnings[i][header])
self.warnings_table.setItem(i, self.header_list.index(header),
item)
self.insert_helper_item(bypass_save_enable)
def insert_helper_item(self, bypass_save_enable=False) -> None:
button = QPushButton("+", self)
self.warnings_table.setRowCount(self.warnings_table.rowCount() + 1)
self.warnings_table.setCellWidget(self.warnings_table.rowCount() - 1,
0, button)
for i in range(self.warnings_table.columnCount()):
item = self.warnings_table.item(self.warnings_table.rowCount() - 1,
i)
if item is None:
item = QTableWidgetItem()
self.warnings_table.setItem(self.warnings_table.rowCount() - 1,
i, item)
item.setFlags(item.flags() ^ Qt.ItemFlag.ItemIsEnabled)
button.setFixedSize(QSize(25, 25))
button.clicked.connect(
lambda: self.insert_new_item(bypass_save_enable))
def updateDockInfo(self):
"""Slot to update the image that the dock widget displays."""
# Only display an image if one item is selected
if (len(self.image_view_lw.selectedItems()) == 0 or
len(self.image_view_lw.selectedItems()) > 1):
self.image_preview_dock.setWindowTitle("Show Image View")
self.display_image_label.clear()
else:
curr_item = self.image_view_lw.currentItem()
self.image_preview_dock.setWindowTitle(curr_item.text())
self.show_dock_act.setText("Show Image View")
# Get the current height of the dock widget
dock_height = self.image_preview_dock.height()
# Get the size of the original image/item
icon_size = curr_item.icon().availableSizes()[0]
icon_width = icon_size.width()
# Return a pixmap from the item's icon and display in the scroll area
pixmap = curr_item.icon().pixmap(QSize(icon_width, dock_height))
self.display_image_label.setPixmap(pixmap)
self.view_scroll_area.setWidget(self.display_image_label)
def createToolBar(self):
"""Set up the toolbar."""
tool_bar = QToolBar("Main Toolbar")
tool_bar.setIconSize(QSize(26, 26))
self.addToolBar(tool_bar)
# Add actions to the toolbar
tool_bar.addAction(self.open_act)
tool_bar.addAction(self.save_act)
tool_bar.addAction(self.print_act)
tool_bar.addAction(self.exit_act)
tool_bar.addSeparator()
tool_bar.addAction(self.crop_act)
tool_bar.addAction(self.resize_act)
tool_bar.addSeparator()
tool_bar.addAction(self.rotate90_ccw_act)
tool_bar.addAction(self.rotate90_cw_act)
tool_bar.addAction(self.flip_horizontal)
tool_bar.addAction(self.flip_vertical)
tool_bar.addSeparator()
tool_bar.addAction(self.zoom_in_act)
tool_bar.addAction(self.zoom_out_act)
def initUI(self):
self.setWindowTitle(self.title)
self.setMinimumHeight(self.height)
self.setMinimumWidth(self.width)
bar = self.menuBar()
about = bar.addMenu("About")
config = bar.addMenu("Configuration")
info = QAction("App Information", self)
about.triggered[QAction].connect(self.aboutThis)
about.addAction(info)
configAction = QAction("System configuration", self)
config.triggered[QAction].connect(self.configWindow)
config.addAction(configAction)
self.setGeometry(self.left, self.top, self.width, self.height)
self.setCentralWidget(self.table_widget)
widget = QWidget()
container = QHBoxLayout()
icon = self.style().standardIcon(
QStyle.StandardPixmap.SP_MessageBoxInformation)
self.iconLabel.setPixmap(icon.pixmap(QSize(16, 16)))
self.restartProcessButton.clicked.connect(self.restartProcess)
container.setSpacing(5)
container.addWidget(self.iconLabel)
container.addWidget(self.informationLabel)
if self.classifyExercises is None:
self.informationLabel.setText(
'Myo Connect is not running!Please start process.')
container.addWidget(self.restartProcessButton)
widget.setLayout(container)
self.statusBar.addWidget(widget)
self.setStatusBar(self.statusBar)
self.show()
def __init__(self, host):
QMainWindow.__init__(self)
self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
screen = QGuiApplication.screens()[1]
screen_width = screen.size().width()
display_width = int(0.7 * screen_width)
display_height = int(0.2 * display_width)
font_size = int(0.06 * display_width)
self.setWindowFlags(Qt.WindowType.WindowStaysOnTopHint
| Qt.WindowType.FramelessWindowHint
| Qt.WindowType.X11BypassWindowManagerHint)
self.setGeometry(
QStyle.alignedRect(
Qt.LayoutDirection.LeftToRight,
Qt.AlignmentFlag.AlignCenter,
QSize(display_width, display_height),
screen.geometry(),
))
font = QFont()
font.setPointSize(font_size)
self.label = QLabel("http://" + host, self)
self.label.setGeometry(self.rect() -
QMargins(0, 0, 0,
self.rect().height() // 2))
self.label.setAlignment(Qt.AlignmentFlag.AlignCenter)
self.label.setFont(font)
self.playerview = PlayerView(self.rect() -
QMargins(0,
self.rect().height() // 2, 0, 0),
fontsize=OVERLAYFONTSIZE,
parent=self)
self.show()
def __init__(self, parent):
QTreeWidget.__init__(self, parent)
self.deleted_parent_map = {}
pal = self.palette()
pal.setColor(QPalette.ColorRole.Highlight,
pal.color(QPalette.ColorRole.Base))
pal.setColor(QPalette.ColorRole.HighlightedText,
pal.color(QPalette.ColorRole.Text))
self.setPalette(pal)
self.setStyleSheet('''
QTreeView {
background: BG;
color: FG;
border: none;
}
QTreeView::item {
border: 1px solid transparent;
padding-top:0.5ex;
padding-bottom:0.5ex;
}
QTreeView::item:hover {
background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 GS, stop: 1 GE);
border: 1px solid BC;
border-radius: 6px;
}
QTreeView::branch {
background: BG;
}
QTreeView::branch:has-children:!has-siblings:closed, QTreeView::branch:closed:has-children:has-siblings {
image: url(CLOSED);
}
QTreeView::branch:open:has-children:!has-siblings, QTreeView::branch:open:has-children:has-siblings {
image: url(OPEN);
}
'''.replace(
'CLOSED', get_data_as_path('images/tree-closed.svg')).replace(
'OPEN', get_data_as_path('images/tree-open.svg')).replace(
'BG',
color('tab tree background', 'palette(window)')).replace(
'FG',
color('tab tree foreground',
'palette(window-text)')).replace(
'GS',
color(
'tab tree hover gradient start',
'#e7effd')).replace(
'GE',
color(
'tab tree hover gradient end',
'#cbdaf1')).replace(
'BC',
color(
'tab tree hover border',
'#bfcde4')))
self.setIconSize(QSize(ICON_SIZE, ICON_SIZE))
self.setAutoScrollMargin(ICON_SIZE * 2)
self.setAnimated(True)
self.setHeaderHidden(True)
self.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
self.setDragEnabled(True)
self.viewport().setAcceptDrops(True)
self.setDropIndicatorShown(True)
self.setDragDropMode(QAbstractItemView.DragDropMode.InternalMove)
self.setDefaultDropAction(Qt.DropAction.MoveAction)
self.invisibleRootItem().setFlags(Qt.ItemFlag.ItemIsDragEnabled
| Qt.ItemFlag.ItemIsDropEnabled
| self.invisibleRootItem().flags())
self.itemClicked.connect(self.item_clicked)
self.current_item = None
self.emphasis_font = QFont(self.font())
self.emphasis_font.setItalic(True)
self.setFocusPolicy(Qt.FocusPolicy.NoFocus)
self.loading_items = set()
self.delegate = TabDelegate(self)
self.setItemDelegate(self.delegate)
self.loading_animation_timer = t = QTimer(self)
t.setInterval(1000 // 60)
t.timeout.connect(self.repaint_loading_items)
self.setMouseTracking(True)
self._last_item = lambda: None
self.itemEntered.connect(self.item_entered)
self.setCursor(Qt.CursorShape.PointingHandCursor)
self.viewport().installEventFilter(self)
self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
self.customContextMenuRequested.connect(self.show_context_menu)
def sizeHint(self):
return QSize(800, 600)
def sizeHint(self, option, index):
size = super().sizeHint(option, index)
return QSize(size.width() + 2, size.height() + 2)
def __init__(self, parent=None):
super(VideoWindow, self).__init__(parent)
self.setWindowTitle("StudioProject")
self.statusBar = QStatusBar()
self.setStatusBar(self.statusBar)
self.gScene = QGraphicsScene(self)
self.gView = GraphicView(self.gScene, self)
self.gView.viewport().setAttribute(
Qt.WidgetAttribute.WA_AcceptTouchEvents, False)
# self.gView.setBackgroundBrush(QBrush(Qt.black))
self.videoStartDatetime = None
self.videoCurrentDatetime = None
self.projectFile = ''
self.graphicsFile = ''
self.videoFile = ''
self.obsTb = ObsToolbox(self)
# # ===================== Setting video item ==============================
# self.videoItem = QGraphicsVideoItem()
# self.videoItem.setAspectRatioMode(Qt.KeepAspectRatio)
# self.gScene.addItem(self.videoItem)
# self.videoItem.mouseMoveEvent = self.gView.mouseMoveEvent
self.mediaPlayer = QMediaPlayer(self)
# self.mediaPlayer.setVideoOutput(self.videoItem)
self.mediaPlayer.playbackStateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.errorOccurred.connect(self.handleError)
# self.mediaPlayer.setMuted(True)
# self.mediaPlayer.setNotifyInterval(100)
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setIcon(self.style().standardIcon(
QStyle.StandardPixmap.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.changePlayRateBtn = QPushButton('1x')
self.changePlayRateBtn.setFixedWidth(40)
# self.incrPlayRateBtn.setEnabled(False)
self.changePlayRateBtn.clicked.connect(self.changePlayRate)
self.positionSlider = QSlider(Qt.Orientation.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.timerLabel = QLabel()
self.timerLabel.setText('--:--:--')
self.timerLabel.setFixedWidth(58)
self.dateLabel = QLabel()
self.dateLabel.setText('Video date: --')
self.statusBar.addPermanentWidget(self.dateLabel)
# Create open action
self.openVideoAction = QAction(QIcon('icons/video-file.png'),
'Open video', self)
self.openVideoAction.setShortcut('Ctrl+O')
self.openVideoAction.setStatusTip('Open video file')
self.openVideoAction.triggered.connect(self.openVideoFile)
# Create observation action
obsTbAction = QAction(QIcon('icons/checklist.png'),
'Observation toolbox', self)
obsTbAction.setStatusTip('Open observation toolbox')
obsTbAction.triggered.connect(self.openObsToolbox)
self.drawPointAction = QAction(QIcon('icons/drawPoint.png'),
'Draw point', self)
self.drawPointAction.setStatusTip('Draw point over the video')
self.drawPointAction.setCheckable(True)
self.drawPointAction.setEnabled(False)
self.drawPointAction.triggered.connect(self.drawingClick)
self.drawLineAction = QAction(QIcon('icons/drawLine.png'), 'Draw line',
self)
self.drawLineAction.setStatusTip('Draw line over the video')
self.drawLineAction.setCheckable(True)
self.drawLineAction.setEnabled(False)
self.drawLineAction.triggered.connect(self.drawingClick)
self.drawZoneAction = QAction(QIcon('icons/drawZone.png'), 'Draw zone',
self)
self.drawZoneAction.setStatusTip('Draw zone over the video')
self.drawZoneAction.setCheckable(True)
self.drawZoneAction.setEnabled(False)
self.drawZoneAction.triggered.connect(self.drawingClick)
self.maskGenAction = QAction(QIcon('icons/mask.png'),
'Generate mask file', self)
self.maskGenAction.setStatusTip(
'Generate mask file for TrafficIntelligence')
self.maskGenAction.setCheckable(True)
self.maskGenAction.setEnabled(False)
self.maskGenAction.triggered.connect(self.generateMask)
actionGroup = QActionGroup(self)
actionGroup.addAction(self.drawPointAction)
actionGroup.addAction(self.drawLineAction)
actionGroup.addAction(self.drawZoneAction)
openProjectAction = QAction(QIcon('icons/open-project.png'),
'Open project', self)
openProjectAction.setStatusTip('Open project')
openProjectAction.triggered.connect(self.openProject)
self.saveProjectAction = QAction(QIcon('icons/save-project.png'),
'Save project', self)
self.saveProjectAction.setStatusTip('Save project')
self.saveProjectAction.setEnabled(False)
self.saveProjectAction.triggered.connect(self.saveProject)
self.saveGraphAction = QAction(QIcon('icons/save-graphics.png'),
'Save graphics', self)
self.saveGraphAction.setStatusTip('Save graphics to database')
self.saveGraphAction.setEnabled(False)
self.saveGraphAction.triggered.connect(self.saveGraphics)
self.loadGraphAction = QAction(QIcon('icons/folders.png'),
'Load graphics', self)
self.loadGraphAction.setStatusTip('Load graphics from database')
self.loadGraphAction.setEnabled(False)
self.loadGraphAction.triggered.connect(self.loadGraphics)
# Create exit action
exitAction = QAction(QIcon('icons/close.png'), 'Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(self.exitCall) # self.exitCall
# Create menu bar and add action
# menuBar = self.menuBar()
# menuBar.setNativeMenuBar(False)
# fileMenu = menuBar.addMenu('&File')
# fileMenu.addAction(openVideoAction)
# fileMenu.addAction(obsTbAction)
# fileMenu.addAction(exitAction)
self.toolbar = self.addToolBar('Tools')
self.toolbar.setIconSize(QSize(24, 24))
self.toolbar.addAction(openProjectAction)
self.toolbar.addAction(self.saveProjectAction)
self.toolbar.addAction(self.openVideoAction)
# self.toolbar.insertSeparator(self.loadGraphAction)
# self.toolbar.addAction(self.loadGraphAction)
# self.toolbar.addAction(self.saveGraphAction)
# self.toolbar.addAction(self.drawPointAction)
# self.toolbar.addAction(self.drawLineAction)
# self.toolbar.addAction(self.drawZoneAction)
self.toolbar.addAction(self.maskGenAction)
# self.toolbar.insertSeparator(self.drawPointAction)
self.toolbar.insertSeparator(obsTbAction)
self.toolbar.addAction(obsTbAction)
self.toolbar.insertSeparator(exitAction)
self.toolbar.addAction(exitAction)
# Create a widget for window contents
wid = QWidget(self)
self.setCentralWidget(wid)
# Create layouts to place inside widget
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
# controlLayout.addWidget(self.decrPlayRateBtn)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.changePlayRateBtn)
controlLayout.addWidget(self.timerLabel)
controlLayout.addWidget(self.positionSlider)
# controlLayout.addWidget(self.durationLabel)
layout = QVBoxLayout()
layout.addWidget(self.gView)
layout.addLayout(controlLayout)
# Set widget to contain window contents
wid.setLayout(layout)
def __init__(self, *args, **kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
layout = QVBoxLayout()
self.editor = TextEdit()
self.editor.setAutoFormatting(QTextEdit.AutoFormatting.AutoAll)
self.editor.selectionChanged.connect(self.update_format)
font = QFont("Times", 12)
self.editor.setFont(font)
self.editor.setFontPointSize(12)
self.path = None
layout.addWidget(self.editor)
container = QWidget()
container.setLayout(layout)
self.setCentralWidget(container)
self.status = QStatusBar()
self.setStatusBar(self.status)
file_toolbar = QToolBar("File")
file_toolbar.setIconSize(QSize(14, 14))
self.addToolBar(file_toolbar)
file_menu = self.menuBar().addMenu("&File")
open_file_action = QAction(
QIcon(os.path.join("images", "blue-folder-open-document.png")),
"Open file...",
self,
)
open_file_action.setStatusTip("Open file")
open_file_action.triggered.connect(self.file_open)
file_menu.addAction(open_file_action)
file_toolbar.addAction(open_file_action)
save_file_action = QAction(QIcon(os.path.join("images", "disk.png")),
"Save", self)
save_file_action.setStatusTip("Save current page")
save_file_action.triggered.connect(self.file_save)
file_menu.addAction(save_file_action)
file_toolbar.addAction(save_file_action)
save_as_file_action = QAction(
QIcon(os.path.join("images", "disk--pencil.png")), "Save As...",
self)
save_as_file_action.setStatusTip("Save current page to specified file")
save_as_file_action.triggered.connect(self.file_save_as)
file_menu.addAction(save_as_file_action)
file_toolbar.addAction(save_as_file_action)
print_action = QAction(QIcon(os.path.join("images", "printer.png")),
"Print...", self)
print_action.setStatusTip("Print current page")
print_action.triggered.connect(self.file_print)
file_menu.addAction(print_action)
file_toolbar.addAction(print_action)
edit_toolbar = QToolBar("Edit")
edit_toolbar.setIconSize(QSize(16, 16))
self.addToolBar(edit_toolbar)
edit_menu = self.menuBar().addMenu("&Edit")
undo_action = QAction(
QIcon(os.path.join("images", "arrow-curve-180-left.png")), "Undo",
self)
undo_action.setStatusTip("Undo last change")
undo_action.triggered.connect(self.editor.undo)
edit_menu.addAction(undo_action)
redo_action = QAction(QIcon(os.path.join("images", "arrow-curve.png")),
"Redo", self)
redo_action.setStatusTip("Redo last change")
redo_action.triggered.connect(self.editor.redo)
edit_toolbar.addAction(redo_action)
edit_menu.addAction(redo_action)
edit_menu.addSeparator()
cut_action = QAction(QIcon(os.path.join("images", "scissors.png")),
"Cut", self)
cut_action.setStatusTip("Cut selected text")
cut_action.setShortcut(QKeySequence.StandardKey.Cut)
cut_action.triggered.connect(self.editor.cut)
edit_toolbar.addAction(cut_action)
edit_menu.addAction(cut_action)
copy_action = QAction(
QIcon(os.path.join("images", "document-copy.png")), "Copy", self)
copy_action.setStatusTip("Copy selected text")
cut_action.setShortcut(QKeySequence.StandardKey.Copy)
copy_action.triggered.connect(self.editor.copy)
edit_toolbar.addAction(copy_action)
edit_menu.addAction(copy_action)
paste_action = QAction(
QIcon(os.path.join("images", "clipboard-paste-document-text.png")),
"Paste",
self,
)
paste_action.setStatusTip("Paste from clipboard")
cut_action.setShortcut(QKeySequence.StandardKey.Paste)
paste_action.triggered.connect(self.editor.paste)
edit_toolbar.addAction(paste_action)
edit_menu.addAction(paste_action)
select_action = QAction(
QIcon(os.path.join("images", "selection-input.png")), "Select all",
self)
select_action.setStatusTip("Select all text")
cut_action.setShortcut(QKeySequence.StandardKey.SelectAll)
select_action.triggered.connect(self.editor.selectAll)
edit_menu.addAction(select_action)
edit_menu.addSeparator()
wrap_action = QAction(
QIcon(os.path.join("images", "arrow-continue.png")),
"Wrap text to window",
self,
)
wrap_action.setStatusTip("Toggle wrap text to window")
wrap_action.setCheckable(True)
wrap_action.setChecked(True)
wrap_action.triggered.connect(self.edit_toggle_wrap)
edit_menu.addAction(wrap_action)
format_toolbar = QToolBar("Format")
format_toolbar.setIconSize(QSize(16, 16))
self.addToolBar(format_toolbar)
format_menu = self.menuBar().addMenu("&Format")
self.fonts = QFontComboBox()
self.fonts.currentFontChanged.connect(self.editor.setCurrentFont)
format_toolbar.addWidget(self.fonts)
self.fontsize = QComboBox()
self.fontsize.addItems([str(s) for s in FONT_SIZES])
self.fontsize.currentTextChanged[str].connect(
lambda s: self.editor.setFontPointSize(float(s)))
format_toolbar.addWidget(self.fontsize)
self.bold_action = QAction(
QIcon(os.path.join("images", "edit-bold.png")), "Bold", self)
self.bold_action.setStatusTip("Bold")
self.bold_action.setShortcut(QKeySequence.StandardKey.Bold)
self.bold_action.setCheckable(True)
self.bold_action.toggled.connect(lambda x: self.editor.setFontWeight(
QFont.Weight.Bold if x else QFont.Weight.Normal))
format_toolbar.addAction(self.bold_action)
format_menu.addAction(self.bold_action)
self.italic_action = QAction(
QIcon(os.path.join("images", "edit-italic.png")), "Italic", self)
self.italic_action.setStatusTip("Italic")
self.italic_action.setShortcut(QKeySequence.StandardKey.Italic)
self.italic_action.setCheckable(True)
self.italic_action.toggled.connect(self.editor.setFontItalic)
format_toolbar.addAction(self.italic_action)
format_menu.addAction(self.italic_action)
self.underline_action = QAction(
QIcon(os.path.join("images", "edit-underline.png")), "Underline",
self)
self.underline_action.setStatusTip("Underline")
self.underline_action.setShortcut(QKeySequence.StandardKey.Underline)
self.underline_action.setCheckable(True)
self.underline_action.toggled.connect(self.editor.setFontUnderline)
format_toolbar.addAction(self.underline_action)
format_menu.addAction(self.underline_action)
format_menu.addSeparator()
self.align_left_action = QAction(
QIcon(os.path.join("images", "edit-alignment.png")), "Align left",
self)
self.align_left_action.setStatusTip("Align text left")
self.align_left_action.setCheckable(True)
self.align_left_action.triggered.connect(
lambda: self.editor.setAlignment(Qt.Alignment.AlignLeft))
format_toolbar.addAction(self.align_left_action)
format_menu.addAction(self.align_left_action)
self.align_center_action = QAction(
QIcon(os.path.join("images", "edit-alignment-center.png")),
"Align center",
self,
)
self.align_center_action.setStatusTip("Align text center")
self.align_center_action.setCheckable(True)
self.align_center_action.triggered.connect(
lambda: self.editor.setAlignment(Qt.Alignment.AlignCenter))
format_toolbar.addAction(self.align_center_action)
format_menu.addAction(self.align_center_action)
self.align_right_action = QAction(
QIcon(os.path.join("images", "edit-alignment-right.png")),
"Align right",
self,
)
self.align_right_action.setStatusTip("Align text right")
self.align_right_action.setCheckable(True)
self.align_right_action.triggered.connect(
lambda: self.editor.setAlignment(Qt.Alignment.AlignRight))
format_toolbar.addAction(self.align_right_action)
format_menu.addAction(self.align_right_action)
self.align_justify_action = QAction(
QIcon(os.path.join("images", "edit-alignment-justify.png")),
"Justify", self)
self.align_justify_action.setStatusTip("Justify text")
self.align_justify_action.setCheckable(True)
self.align_justify_action.triggered.connect(
lambda: self.editor.setAlignment(Qt.Alignment.AlignJustify))
format_toolbar.addAction(self.align_justify_action)
format_menu.addAction(self.align_justify_action)
format_group = QActionGroup(self)
format_group.setExclusive(True)
format_group.addAction(self.align_left_action)
format_group.addAction(self.align_center_action)
format_group.addAction(self.align_right_action)
format_group.addAction(self.align_justify_action)
format_menu.addSeparator()
self._format_actions = [
self.fonts,
self.fontsize,
self.bold_action,
self.italic_action,
self.underline_action,
]
self.update_format()
self.update_title()
self.show()
def sizeHint(self, option, index):
return QSize(300, ICON_SIZE + 2 * self.MARGIN)