class StatusWidget(QWidget):
def __init__(self):
super().__init__()
self.status_label = QLabel("0%")
self.load_icon_movie = QMovie(SpinnerIconPath)
self.load_icon_label = QLabel()
self.load_icon_label.setMovie(self.load_icon_movie)
self.layout = QHBoxLayout()
self.layout.addStretch(2)
self.layout.addWidget(self.load_icon_label)
self.layout.addWidget(self.status_label)
self.layout.addStretch(3)
self.layout.setSpacing(0)
self.layout.setMargin(0)
self.layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.layout)
def update_progress(self, new_progress):
self.status_label.setText(str(new_progress) + "%")
def start_loading(self):
self.load_icon_movie.start()
def stop_loading(self):
self.load_icon_movie.stop()
class xASL_ImagePlayer(QLabel):
def __init__(self,
filepath,
parent=None,
alignment=Qt.AlignLeft,
h_offset=0,
v_offset=5,
initial_movie_size=None):
"""
A modified QLabel which features a GIF movie that can be played
Parameters:
• filepath: The filepath to the .gif file which will be played
• parent: The parent of this widget
• alignment: The alignment of the movie w.r.t the label itself
• h_offset: When resizing based on a buddy widget, the additional horizontal size that should be given
• v_offset: When resizing based on a buddy widget, the additional vertical size that should be given
• initial_movie_size: None, QSize or a 2-element tuple to indicate the initial pixel dimensions that
the movie should be set to
"""
super(xASL_ImagePlayer, self).__init__(parent=parent)
self.h_offset, self.v_offset = h_offset, v_offset
self.setContentsMargins(0, 0, 0, 0)
self.setAlignment(alignment)
# Load the file into a QMovie with the appropriate size
self.movie = QMovie(str(filepath), QByteArray(), self)
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
self.setMovie(self.movie)
self.ping()
if initial_movie_size is not None:
if isinstance(initial_movie_size, tuple):
initial_movie_size = QSize(*initial_movie_size)
self.movie.setScaledSize(initial_movie_size)
def ping(self):
self.movie.start()
self.movie.stop()
self.movie.jumpToFrame(0)
@Slot(int, int)
def listen_resize(self, width, height):
self.movie.setScaledSize(
QSize(width + self.h_offset, height + self.v_offset))
self.ping()
class AnimatedSplash(QSplashScreen):
def __init__(self, path):
self.__movie = QMovie(path)
self.__movie.jumpToFrame(0)
pixmap = QPixmap(self.__movie.frameRect().size())
QSplashScreen.__init__(self, pixmap)
self.__movie.frameChanged.connect(self.repaint)
def showEvent(self, event):
self.__movie.start()
def hideEvent(self, event):
self.__movie.stop()
def paintEvent(self, event):
painter = QPainter(self)
pixmap = self.__movie.currentPixmap()
self.setMask(pixmap.mask())
painter.drawPixmap(0, 0, pixmap)
class NotificationsDialog(object):
def __init__(self, parent, parent_window, notifications, dp=None):
self._dialog = QDialog(parent_window)
self._dp = dp
self._notifications = notifications
self._parent = parent
self._parent_window = parent_window
self._dialog.setWindowIcon(QIcon(':/images/icon.png'))
self._ui = Ui_Dialog()
self._ui.setupUi(self._dialog)
self._init_ui()
def _init_ui(self):
self._dialog.setWindowFlags(Qt.Dialog)
self._dialog.setAttribute(Qt.WA_TranslucentBackground)
self._dialog.setAttribute(Qt.WA_MacFrameworkScaled)
self._notifications_list = NotificationsList(self._dp)
self._ui.notifications_area.setWidget(self._notifications_list)
self._ui.notifications_area.verticalScrollBar().valueChanged.connect(
self._on_list_scroll_changed)
self._old_main_resize_event = self._ui.centralwidget.resizeEvent
self._ui.centralwidget.resizeEvent = self._main_resize_event
self._loader_movie = QMovie(":/images/loader.gif")
self._ui.loader_label.setMovie(self._loader_movie)
def show(self, on_finished):
def finished():
self.show_cursor_normal()
self._dialog.finished.disconnect(finished)
on_finished()
logger.debug("Opening notifications dialog")
screen_width = QApplication.desktop().width()
parent_x = self._dialog.parent().x()
parent_width = self._dialog.parent().width()
width = self._dialog.width()
offset = 16
if parent_x + parent_width / 2 > screen_width / 2:
x = parent_x - width - offset
if x < 0:
x = 0
else:
x = parent_x + parent_width + offset
diff = x + width - screen_width
if diff > 0:
x -= diff
self._dialog.move(x, self._dialog.parent().y())
# Execute dialog
self._dialog.finished.connect(finished)
if not self._parent.load_notifications(show_loading=True):
self.show_notifications()
self._dialog.raise_()
self._dialog.show()
def raise_dialog(self):
self._dialog.raise_()
def close(self):
self._dialog.reject()
def show_cursor_loading(self, show_movie=False):
if show_movie:
self._ui.notifications_pages.setCurrentIndex(2)
self._loader_movie.start()
else:
self._dialog.setCursor(Qt.WaitCursor)
self._parent_window.setCursor(Qt.WaitCursor)
def show_cursor_normal(self):
self._dialog.setCursor(Qt.ArrowCursor)
self._parent_window.setCursor(Qt.ArrowCursor)
if self._loader_movie.state() == QMovie.Running:
self._loader_movie.stop()
def show_notifications(self):
if not self._notifications:
self._ui.notifications_pages.setCurrentIndex(1)
else:
self._ui.notifications_pages.setCurrentIndex(0)
self._notifications_list.show_notifications(self._notifications)
self.show_cursor_normal()
def _on_list_scroll_changed(self, *args, **kwargs):
# value = self._ui.notifications_area.verticalScrollBar().value()
# logger.debug("Scroll value %s", value)
if self._parent.all_loaded or self._parent.is_querying:
return
if self._notifications_list.loading_needed(self._parent.limit):
logger.debug("Loading notifications")
self._parent.load_notifications()
def _main_resize_event(self, e):
self._old_main_resize_event(e)
self._notifications_list.setFixedWidth(
self._ui.notifications_pages.width() - 8)
self._on_list_scroll_changed()
class UpdatePrompt(QDialog):
def __init__(self):
super().__init__()
self.makeView()
return
def makeView(self):
layout = QVBoxLayout()
btnLayout = QHBoxLayout()
self.centStack = QStackedWidget()
self.updateButton = QPushButton('Update')
self.cancelButton = QPushButton('Cancel')
notifyLabel = QLabel('There are upgrades scheduled')
self.inputBox = QLineEdit()
self.outputBox = QTextBrowser()
#refreshIcon = QIcon.fromTheme('process-working')
self.refreshIcon = QMovie('assets/spin3.gif')
refreshAnimation = QLabel()
layout.addWidget(notifyLabel)
layout.addWidget(self.centStack)
layout.addWidget(self.inputBox)
layout.addLayout(btnLayout)
btnLayout.addWidget(self.cancelButton)
btnLayout.addWidget(self.updateButton)
self.centStack.addWidget(refreshAnimation)
self.centStack.addWidget(self.outputBox)
refreshAnimation.setMovie(self.refreshIcon)
refreshAnimation.setAlignment(Qt.AlignCenter)
self.refreshIcon.start()
self.inputBox.setEchoMode(QLineEdit.Password)
self.inputBox.setFocus()
self.inputBox.returnPressed.connect(self.pkgUpdates)
self.updateButton.clicked.connect(self.pkgUpdates)
self.cancelButton.clicked.connect(self.cancelUpdates)
self.updateButton.setDefault(True)
self.centStack.setCurrentIndex(1)
notifyLabel.setAlignment(Qt.AlignTop)
self.outputBox.setReadOnly(True)
#self.outputBox.setAlignment(Qt.AlignTop)
self.setWindowTitle('Package Upgrades')
self.setLayout(layout)
self.resize(450, 250)
return
async def asetup(self, password):
async with trio.open_nursery() as nursery:
finishedState = trio.Event()
nursery.start_soon(self.upProc, password, 'update', finishedState)
#nursery.start_soon(self.KEAlive, finishedState)
return
async def upProc(self, password, cmd, finishedState):
proc = await trio.open_process(['sudo', '-S', 'apt-get', cmd, '-y'],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
await proc.stdin.send_all((password + '\n').encode())
while (proc.poll() == None):
QCoreApplication.processEvents()
await trio.sleep(0.1)
result = ''
result = await self.pullOutput(proc)
self.appendToOutput(result)
proc.terminate()
if (cmd == 'update'):
await self.upProc(password, 'upgrade', finishedState)
finishedState.set()
return
async def pullOutput(self, proc):
x = await proc.stdout.receive_some()
x = x.decode()
result = ''
while (x != ''):
QCoreApplication.processEvents()
result = result + x
x = await proc.stdout.receive_some()
x = x.decode()
return result
async def KEAlive(self, finishedState):
while finishedState.is_set():
QCoreApplication.processEvents()
trio.sleep(0.1)
return
return
def appendToOutput(self, add):
currentText = self.outputBox.toPlainText()
self.outputBox.setText(currentText + 'Running updates\n' + add + '\n')
print(add)
return
def pkgUpdates(self):
self.centStack.setCurrentIndex(0)
self.refreshIcon.start()
QCoreApplication.processEvents()
password = self.inputBox.text()
if (password == ''):
self.passError('The password field cannot be empty')
return
self.inputBox.clear()
self.inputBox.setDisabled(True)
self.updateButton.setDisabled(True)
trio.run(self.asetup, password)
self.centStack.setCurrentIndex(1)
self.refreshIcon.stop()
self.updateButton.setDisabled(False)
self.inputBox.setDisabled(False)
return
def passError(self, s):
passError = QDialog(self)
msg = QLabel(s)
layout = QVBoxLayout()
layout.addWidget(msg)
passError.setLayout(layout)
okBtn = QPushButton('OK')
okBtn.clicked.connect(passError.reject)
layout.addWidget(okBtn)
passError.exec_()
return
def cancelUpdates(self):
#Needs way of closing subprocess during async run
self.reject()
return
class LoadingVideosInfoDialog(QDialog):
def __init__(self, videos_list):
super().__init__()
self.setWindowTitle("Loading Media Info")
self.videos_list = videos_list
self.videos_count = len(self.videos_list)
self.current_video_done_index = 0
self.status_label = QLabel("Scanning Video " +
str(self.current_video_done_index) + "/" +
str(self.videos_count))
self.load_icon_movie = QMovie(SpinnerIconPath)
self.load_icon_label = QLabel()
self.load_icon_label.setMovie(self.load_icon_movie)
self.layout = QHBoxLayout()
self.layout.addStretch(2)
self.layout.addWidget(self.load_icon_label)
self.layout.addWidget(self.status_label)
self.layout.addStretch(3)
self.layout.setSpacing(0)
self.layout.setContentsMargins(8, 12, 8, 12)
self.setLayout(self.layout)
self.disable_question_mark_window()
self.generate_media_info_files()
# noinspection PyAttributeOutsideInit
def generate_media_info_files(self):
self.generate_media_info_files_thread = QThread()
self.generate_media_info_files_worker = GenerateMediaInfoFilesWorker(
self.videos_list)
self.generate_media_info_files_worker.moveToThread(
self.generate_media_info_files_thread)
self.generate_media_info_files_thread.started.connect(
self.generate_media_info_files_worker.run)
self.generate_media_info_files_worker.job_succeeded_signal.connect(
self.update_progress)
self.generate_media_info_files_worker.finished_all_jobs_signal.connect(
self.generate_media_info_files_thread.quit)
self.generate_media_info_files_worker.finished_all_jobs_signal.connect(
self.generate_media_info_files_worker.deleteLater)
self.generate_media_info_files_thread.finished.connect(
self.generate_media_info_files_thread.deleteLater)
self.generate_media_info_files_thread.finished.connect(
self.stop_loading)
self.start_loading()
self.generate_media_info_files_thread.start()
def disable_question_mark_window(self):
self.setWindowFlag(Qt.WindowContextHelpButtonHint, on=False)
def update_progress(self):
self.current_video_done_index += 1
self.status_label.setText(" Scanning Video " +
str(self.current_video_done_index) + "/" +
str(self.videos_count))
def start_loading(self):
self.load_icon_movie.start()
def stop_loading(self):
time.sleep(0.1)
self.load_icon_movie.stop()
self.close()
def execute(self):
self.exec()
class CollaborationSettingsDialog(object):
ADD_BUTTON_ACTIVE_COLOR = "#f78d1e"
ADD_BUTTON_PASSIVE_COLOR = "#9a9a9a"
ERROR_COLOR = '#FF9999'
LINE_EDIT_NORMAL_COLOR = "#EFEFF1"
def __init__(self, parent, parent_window, colleagues, folder, dp):
self._dialog = QDialog(parent_window)
self._dp = dp
self._colleagues = colleagues
self._parent = parent
self._parent_window = parent_window
self._folder = folder
self._is_owner = False
self._dialog.setWindowIcon(QIcon(':/images/icon.png'))
self._ui = Ui_Dialog()
self._ui.setupUi(self._dialog)
self._init_ui()
def _init_ui(self):
self._dialog.setWindowFlags(Qt.Dialog)
self._dialog.setAttribute(Qt.WA_TranslucentBackground)
self._dialog.setAttribute(Qt.WA_MacFrameworkScaled)
self._dialog.setWindowTitle(self._dialog.windowTitle() + self._folder)
self._ui.colleagues_list.setAlternatingRowColors(True)
self._colleagues_list = ColleaguesList(self._parent,
self._ui.colleagues_list,
self._dp, self._show_menu)
self._loader_movie = QMovie(":/images/loader.gif")
self._ui.loader_label.setMovie(self._loader_movie)
self._set_fonts()
self._ui.add_frame.setVisible(False)
self._set_add_button_background(self.ADD_BUTTON_PASSIVE_COLOR)
self._ui.add_button.clicked.connect(self._on_add_button_clicked)
self._ui.add_button.setVisible(False)
self._ui.close_button.clicked.connect(self._on_close_button_clicked)
self._ui.refresh_button.clicked.connect(self._on_refresh)
self._line_edit_style = "background-color: {};"
self._ui.error_label.setStyleSheet("color: {};".format(
self.ERROR_COLOR))
def _set_fonts(self):
ui = self._ui
controls = [
ui.colleagues_label, ui.mail_edit, ui.edit_radio, ui.view_radio,
ui.add_button
]
for control in controls:
font = control.font()
font_size = control.font().pointSize() * self._dp
if font_size > 0:
control_font = QFont(font.family(), font_size)
control_font.setBold(font.bold())
control.setFont(control_font)
def show(self):
logger.debug("Opening collaboration settings dialog")
screen_width = QApplication.desktop().width()
parent_x = self._dialog.parent().x()
parent_width = self._dialog.parent().width()
width = self._dialog.width()
offset = 16
if parent_x + parent_width / 2 > screen_width / 2:
x = parent_x - width - offset
if x < 0:
x = 0
else:
x = parent_x + parent_width + offset
diff = x + width - screen_width
if diff > 0:
x -= diff
self._dialog.move(x, self._dialog.parent().y())
# Execute dialog
self._dialog.raise_()
self.show_cursor_loading(True)
self._dialog.exec_()
def close(self):
self._dialog.reject()
def show_cursor_loading(self, show_movie=False):
if show_movie:
self._ui.stackedWidget.setCurrentIndex(1)
self._loader_movie.start()
else:
self._dialog.setCursor(Qt.WaitCursor)
self._parent_window.setCursor(Qt.WaitCursor)
def show_cursor_normal(self):
self._dialog.setCursor(Qt.ArrowCursor)
self._parent_window.setCursor(Qt.ArrowCursor)
if self._loader_movie.state() == QMovie.Running:
self._loader_movie.stop()
def show_colleagues(self):
if not self._colleagues:
self._ui.stackedWidget.setCurrentIndex(2)
else:
self._ui.stackedWidget.setCurrentIndex(0)
self._colleagues_list.show_colleagues(self._colleagues)
self.show_cursor_normal()
def set_owner(self, is_owner):
self._is_owner = is_owner
self._ui.add_button.setVisible(self._is_owner)
def _on_add_button_clicked(self):
if self._ui.add_frame.isVisible():
if not self._validate_email():
return
to_edit = self._ui.edit_radio.isChecked()
self._ui.add_frame.setVisible(False)
self._set_add_button_background(self.ADD_BUTTON_PASSIVE_COLOR)
self._parent.add_colleague(self._ui.mail_edit.text(), to_edit)
else:
self._ui.add_frame.setVisible(True)
self._set_add_button_background(self.ADD_BUTTON_ACTIVE_COLOR)
self._ui.mail_edit.setText("")
def _set_add_button_background(self, color):
self._ui.add_button.setStyleSheet(
'background-color: {}; color: #fff; '
'border-radius: 4px; font: bold "Gargi"'.format(color))
def _on_close_button_clicked(self):
self._ui.add_frame.setVisible(False)
self._set_add_button_background(self.ADD_BUTTON_PASSIVE_COLOR)
self._clear_error()
self._ui.mail_edit.setText("")
def _validate_email(self):
email_control = self._ui.mail_edit
email_control.setStyleSheet(
self._line_edit_style.format(self.LINE_EDIT_NORMAL_COLOR))
regex = '^.+@.{2,}$'
email_control.setText(email_control.text().strip())
if not re.match(regex, email_control.text()):
self._ui.error_label.setText(tr("Please enter a valid e-mail"))
email_control.setStyleSheet(
self._line_edit_style.format(self.ERROR_COLOR))
email_control.setFocus()
return False
self._clear_error()
return True
def _clear_error(self):
self._ui.error_label.setText("")
self._ui.mail_edit.setStyleSheet(
self._line_edit_style.format(self.LINE_EDIT_NORMAL_COLOR))
def _on_refresh(self):
self.show_cursor_loading()
self._parent.query_collaboration_info()
def _show_menu(self, colleague, pos):
if not self._is_owner and not colleague.is_you or colleague.is_deleting:
return
menu = QMenu(self._ui.colleagues_list)
menu.setStyleSheet("background-color: #EFEFF4; ")
if colleague.is_you:
if colleague.is_owner:
action = menu.addAction(tr("Quit collaboration"))
action.triggered.connect(self._on_quit_collaboration)
else:
action = menu.addAction(tr("Leave collaboration"))
action.triggered.connect(self._on_leave_collaboration)
else:
rights_group = QActionGroup(menu)
rights_group.setExclusive(True)
menu.addSection(tr("Access rights"))
action = menu.addAction(tr("Can view"))
action.setCheckable(True)
rights_action = rights_group.addAction(action)
rights_action.setData(False)
rights_action.setChecked(not colleague.can_edit)
action = menu.addAction(tr("Can edit"))
action.setCheckable(True)
rights_action = rights_group.addAction(action)
rights_action.setChecked(colleague.can_edit)
rights_action.setData(True)
rights_group.triggered.connect(
lambda a: self._on_grant_edit(colleague, a))
menu.addSeparator()
action = menu.addAction(tr("Remove user"))
action.triggered.connect(lambda: self._on_remove_user(colleague))
pos_to_show = QPoint(pos.x(), pos.y() + 10)
menu.exec_(pos_to_show)
def _on_quit_collaboration(self):
alert_str = "Collaboration will be cancelled, " \
"collaboration folder will be deleted " \
"from all colleagues' Pvtbox secured sync folders " \
"on all nodes."
if self._user_confirmed_action(alert_str):
self._parent.cancel_collaboration()
def _on_leave_collaboration(self):
alert_str = "Collaboration folder will be deleted " \
"from Pvtbox secured sync folders " \
"on all your nodes."
if self._user_confirmed_action(alert_str):
self._parent.leave_collaboration()
def _on_remove_user(self, colleague):
alert_str = "Colleague {} will be removed from collaboration. " \
"Collaboration folder will be deleted from colleague's " \
"Pvtbox secured sync folders on all nodes." \
.format(colleague.email)
if self._user_confirmed_action(alert_str):
self._parent.remove(colleague.id)
def _on_grant_edit(self, colleague, action):
to_edit = action.data()
self._parent.grant_edit(colleague.id, to_edit)
def _user_confirmed_action(self, alert_str):
msg = tr("<b>Are</b> you <b>sure</b>?<br><br>{}".format(alert_str))
user_answer = msgbox(msg,
title=' ',
buttons=[
(tr('Cancel'), 'Cancel'),
(tr('Yes'), 'Yes'),
],
parent=self._dialog,
default_index=0,
enable_close_button=True)
return user_answer == 'Yes'
class SmartSyncDialog(object):
def __init__(self, parent):
self._dialog = QDialog(parent)
self._dialog.setWindowIcon(QIcon(':/images/icon.png'))
self._ui = Ui_Dialog()
self._ui.setupUi(self._dialog)
self._ui.centralWidget.setFrameShape(QFrame.NoFrame)
self._ui.centralWidget.setLineWidth(1)
self._model = None
self._proxy_model = QSortFilterProxyModel()
self._view = self._ui.folder_list_view
self._view.setModel(self._proxy_model)
self._view.expanded.connect(self.on_item_expanded)
self._offline_paths = None
# for frameless window moving
self._x_coord = 0
self._y_coord = 0
self._dialog.mousePressEvent = self.on_mouse_press_event
self._dialog.mouseMoveEvent = self.on_mouse_move_event
self._loader_movie = QMovie(":/images/loader.gif")
self._ui.loader_label.setMovie(self._loader_movie)
def on_mouse_press_event(self, ev):
self._x_coord = ev.x()
self._y_coord = ev.y()
def on_mouse_move_event(self, ev):
self._dialog.move(
ev.globalX() - self._x_coord, ev.globalY() - self._y_coord)
def on_item_expanded(self, index):
if self._model:
self._model.on_item_expanded(self._proxy_model.mapToSource(index))
def show(self, root_path, hide_dotted=False):
if LOGGING_ENABLED:
logger.info(
"Opening smart sync dialog for path '%s'...", root_path)
self._model = TreeModel(
root_path, hide_dotted=hide_dotted)
self._proxy_model.setSourceModel(self._model)
self.show_cursor_loading(show_movie=True)
# Execute dialog
result = self._dialog.exec_()
if result == QDialog.Accepted:
offline_dirs = self._model.get_added_to_offline_paths()
new_online = list(self._model.get_removed_from_offline_paths())
new_offline = list(offline_dirs - self._offline_paths)
if LOGGING_ENABLED:
logger.debug("new offline dirs %s, new online dirs %s",
new_offline, new_online)
return new_offline, new_online
else:
return [], []
def set_offline_paths(self, offline_paths):
self._offline_paths = offline_paths
logger.debug("offline paths %s", offline_paths)
self._model.set_offline_dirs(offline_paths)
self.show_cursor_normal()
self._view.expand(self._proxy_model.mapFromSource(
self._model.get_root_path_index()))
self._proxy_model.sort(0, Qt.AscendingOrder)
def show_cursor_loading(self, show_movie=False):
if show_movie:
self._ui.stackedWidget.setCurrentIndex(1)
self._loader_movie.start()
else:
self._dialog.setCursor(Qt.WaitCursor)
def show_cursor_normal(self):
self._dialog.setCursor(Qt.ArrowCursor)
if self._loader_movie.state() == QMovie.Running:
self._loader_movie.stop()
self._ui.stackedWidget.setCurrentIndex(0)
class Ui_ScrollArea(object):
def setupUi(self, ScrollArea):
if ScrollArea.objectName():
ScrollArea.setObjectName(u"ScrollArea")
flags = Qt.WindowFlags(Qt.FramelessWindowHint)
ScrollArea.setWindowFlags(flags)
ScrollArea.resize(899, 603)
ScrollArea.setMaximumSize(QSize(899, 671))
ScrollArea.setStyleSheet(u"background-color: #2c3e50;")
ScrollArea.setWidgetResizable(False)
#ScrollArea.setAlignment(Qt.AlignCenter)
self.threadpool = QThreadPool()
self.scrollAreaWidgetContents = QWidget()
self.scrollAreaWidgetContents.setObjectName(
u"scrollAreaWidgetContents")
self.scrollAreaWidgetContents.setGeometry(QRect(0, 0, 897, 601))
self.label = QLabel(self.scrollAreaWidgetContents)
self.label.setObjectName(u"label")
self.label.setGeometry(QRect(0, 0, 901, 81))
self.label.setStyleSheet(u"background-color: #262b33;")
self.tabWidget = QTabWidget(self.scrollAreaWidgetContents)
self.tabWidget.setObjectName(u"tabWidget")
self.tabWidget.setGeometry(QRect(0, 80, 901, 591))
font = QFont()
font.setBold(True)
font.setWeight(75)
self.tabWidget.setFont(font)
self.tabWidget.setStyleSheet(
"QTabWidget>QWidget>QWidget{background: #2f3640;}\n"
"QTabBar::tab{background-color: #2f3640;color: white}\n"
"QTabBar::tab:selected{background-color: rgb(29, 29, 29);}\n QTabBar{qproperty-drawBase: 0;}"
)
self.tabWidget.setTabPosition(QTabWidget.West)
self.tabWidget.setIconSize(QSize(70, 100))
self.tabWidget.setTabBarAutoHide(True)
self.tabWidget.setDocumentMode(True)
self.tabWidget.setTabsClosable(False)
self.tabWidget.setMovable(False)
iconSave = QIcon()
iconSave.addFile(os.path.join('gpr', 'ButtonSaveIcon.png'), QSize(),
QIcon.Normal, QIcon.On)
PlayButton = QIcon()
PlayButton.addFile(os.path.join('gpr', 'PlayButton.png'), QSize(),
QIcon.Normal, QIcon.On)
AddMore = QIcon()
AddMore.addFile(os.path.join('gpr', 'Addmore.png'), QSize(),
QIcon.Normal, QIcon.On)
iconMinus = QIcon()
iconMinus.addFile(os.path.join('gpr', 'RemoveButton.png'), QSize(),
QIcon.Normal, QIcon.On)
icon = QIcon()
icon.addFile(os.path.join('gpr', 'FolderIcon.png'), QSize(),
QIcon.Normal, QIcon.On)
icon2 = QIcon()
icon2.addFile(os.path.join('gpr', 'ico2.png'), QSize(), QIcon.Normal,
QIcon.On)
self.tab = QWidget()
self.tab.setObjectName(u"tab")
self.label_9 = QLabel(self.tab)
self.label_9.setObjectName(u"label_9")
self.label_9.setGeometry(QRect(10, 0, 251, 231))
self.label_9.setStyleSheet(u"background-color: #8BC34A;")
self.label_10 = QLabel(self.tab)
self.label_10.setObjectName(u"label_10")
self.label_10.setGeometry(QRect(270, 0, 541, 231))
self.label_10.setStyleSheet(u"background-color: #CDDC39;")
self.label_12 = QLabel(self.tab)
self.label_12.setObjectName(u"label_12")
self.label_12.setGeometry(QRect(10, 240, 801, 341))
self.label_12.setStyleSheet(u"background-color: #222f3e;")
self.OpenFileFolder = QPushButton(self.tab)
self.OpenFileFolder.setObjectName(u"OpenFileFolder")
self.OpenFileFolder.setGeometry(QRect(80, 40, 120, 120))
self.OpenFileFolder.setStyleSheet(
u"border:none;\n"
"background-color: rgb(46, 52, 54)\n;"
"color:white;")
self.OpenFileFolder.setIcon(AddMore)
self.OpenFileFolder.setIconSize(QSize(100, 100))
self.WidthVideo = QLineEdit(self.tab)
self.WidthVideo.setObjectName(u"WidthMany")
self.WidthVideo.setGeometry(QRect(320, 100, 201, 27))
self.WidthVideo.setStyleSheet(u"border:none;\n"
"background-color: white;\n"
"color: black;")
self.SaveVideo = QPushButton(self.tab)
self.SaveVideo.setObjectName(u"SaveMany")
self.SaveVideo.setGeometry(QRect(550, 40, 141, 141))
self.SaveVideo.setStyleSheet(u"border:none;\n"
"background-color: rgb(46, 52, 54);\n"
"color:white")
self.SaveVideo.setIcon(iconSave)
self.SaveVideo.setIconSize(QSize(100, 100))
self.animatedContainer = QLabel(self.tab)
self.animatedContainer.setObjectName(u"animated")
self.animatedContainer.setGeometry(QRect(100, 435, 80, 80))
self.animatedContainer.setScaledContents(False)
self.animatedContainer.setStyleSheet(u"border:none;\n"
"background-color: #222f3e")
self.movieAnimation = QMovie(
os.path.join('gpr', 'Loading', 'animation.gif'))
self.animatedContainer.setMovie(self.movieAnimation)
self.InfoText = QLineEdit(self.tab)
self.InfoText.setObjectName(u"InfoText")
self.InfoText.setGeometry(QRect(470, 480, 300, 27))
self.InfoText.setStyleSheet(u"background-color: #222f3e;\n"
"border:none;\n"
"color:white;")
self.InfoText.setReadOnly(True)
self.CloseX = QPushButton(self.scrollAreaWidgetContents)
self.CloseX.setObjectName(u"CloseButtonX")
self.CloseX.setGeometry(QRect(850, 0, 31, 27))
self.CloseX.setStyleSheet(u"background-color:2f3640;\n"
"color:white;\n"
"border:none;")
self.MinimizedWindow = QPushButton(self.scrollAreaWidgetContents)
self.MinimizedWindow.setObjectName(u"Minimized Window")
self.MinimizedWindow.setGeometry(QRect(810, 0, 31, 27))
self.MinimizedWindow.setStyleSheet(u"background-color:2f3640;\n"
"color:white;\n"
"border:none;")
self.MinusButton = QPushButton(self.tab)
self.MinusButton.setObjectName(u"SaveMany")
self.MinusButton.setGeometry(QRect(190, 165, 60, 60))
self.MinusButton.setStyleSheet(u"border:none;\n"
"background-color: rgb(46, 52, 54);")
self.MinusButton.setIcon(iconMinus)
self.MinusButton.setIconSize(QSize(50, 50))
self.HeightVideo = QLineEdit(self.tab)
self.HeightVideo.setObjectName(u"HeightVideo")
self.HeightVideo.setGeometry(QRect(320, 40, 201, 27))
self.HeightVideo.setStyleSheet(u"border:none;\n"
"background-color: white;\n"
"color: black;")
self.Fps = QLineEdit(self.tab)
self.Fps.setObjectName(u"FPS")
self.Fps.setGeometry(QRect(320, 160, 201, 27))
self.Fps.setStyleSheet(u"border:none;\n"
"background-color: white;\n"
"color: black;")
self.OpenFolder = QPushButton(self.tab)
self.OpenFolder.setObjectName(u"OpenFolder")
self.OpenFolder.setGeometry(QRect(670, 430, 90, 90))
self.OpenFolder.setStyleSheet(u"border:none;\n"
"background-color: rgb(46, 52, 54);")
self.OpenFolder.setIcon(icon)
self.OpenFolder.setIconSize(QSize(80, 80))
self.OpenFolder.setEnabled(False)
self.OpenFolder.setVisible(False)
self.areaTabTable = QTableWidget(self.tab)
self.areaTabTable.setGeometry(QRect(10, 240, 781, 192))
self.areaTabTable.setShowGrid(True)
self.areaTabTable.setColumnCount(2)
self.areaTabTable.setStyleSheet(u"border:none;\n"
"background-color: white;\n"
"color: black;")
self.areaTabTable.setHorizontalHeaderLabels(
['Videos', 'Extract Time Range (From-To)'])
self.areaTabTable.horizontalHeader().resizeSection(0, 380)
self.areaTabTable.horizontalHeader().resizeSection(1, 380)
self.StartButton = QPushButton(self.tab)
self.StartButton.setObjectName(u"StartButton")
self.StartButton.setGeometry(QRect(360, 435, 91, 81))
self.StartButton.setStyleSheet(u"border:none;\n"
"background-color: rgb(46, 52, 54);")
self.StartButton.setIcon(PlayButton)
self.StartButton.setIconSize(QSize(40, 40))
icon3 = QIcon()
icon3.addFile(u"gpr\ico4.png", QSize(), QIcon.Normal, QIcon.On)
self.tabWidget.addTab(self.tab, icon3, "1")
self.tab_2 = QWidget()
self.tab_2.setObjectName(u"tab_2")
self.label_3 = QLabel(self.tab_2)
self.label_3.setObjectName(u"label_3")
self.label_3.setGeometry(QRect(350, 120, 31, 41))
self.label_3.setStyleSheet(u"background-color: #2f3640;")
self.label_3.setPixmap(QPixmap(os.path.join('gpr',
'LogoTopSmall.png')))
self.label_3.setScaledContents(True)
icon4 = QIcon()
icon4.addFile(os.path.join('gpr', 'ico3.png'), QSize(), QIcon.Normal,
QIcon.On)
self.label_11 = QLabel(self.scrollAreaWidgetContents)
self.label_11.setObjectName(u"label_11")
self.label_11.setGeometry(QRect(50, 20, 31, 41))
self.label_11.setStyleSheet(u"background-color: #262b33;")
self.label_11.setPixmap(
QPixmap(os.path.join('gpr', 'LogoTopSmall.png')))
self.label_11.setScaledContents(True)
self.Tagline = QLineEdit(self.scrollAreaWidgetContents)
self.Tagline.setObjectName(u"lineEdit")
self.Tagline.setGeometry(QRect(660, 50, 200, 27))
self.Tagline.setStyleSheet(u"background-color: #262b33;\n"
"border:none;\n"
"color:white;")
self.Tagline.setReadOnly(True)
ScrollArea.setWidget(self.scrollAreaWidgetContents)
self.CloseX.pressed.connect(self.CloseProgram)
self.MinimizedWindow.pressed.connect(self.Minimize)
self.OpenFileFolder.pressed.connect(self.AppendMovieTimeSheet)
self.MinusButton.pressed.connect(self.RemoveTable)
self.StartButton.pressed.connect(self.SaveCSVFile)
self.SaveVideo.pressed.connect(self.SaveConfigurationVideo)
self.StartButton.setEnabled(False)
self.OpenFolder.pressed.connect(self.FolderPath)
self.retranslateUi(ScrollArea)
self.tabWidget.setCurrentIndex(2)
QMetaObject.connectSlotsByName(ScrollArea)
def FolderPath(self):
pathOS = os.getcwd()
if platform.system() == "Windows":
os.startfile(os.getcwd(pathOS))
else:
QMessageBox.information(None, "Successful!",
"The file has been saved at " + pathOS)
def CloseProgram(self):
app.quit()
def Minimize(self):
ScrollArea.setWindowState(Qt.WindowMinimized)
def Processing(self):
time.sleep(0.1)
self.movieAnimation.start()
self.animatedContainer.setVisible(True)
self.InfoText.setText("Processing, Grab a Cup of Coffee! ..")
self.ThreadProcess()
self.StartButton.setEnabled(False)
self.OpenFolder.setEnabled(False)
self.OpenFolder.setVisible(False)
def ThreadProcess(self):
threadClass = MainThread()
time.sleep(0.1)
self.threadpool.start(threadClass)
threadClass.signals.finished.connect(self.OnComplete)
return
def OnComplete(self):
self.InfoText.setText("Done!")
self.movieAnimation.stop()
self.StartButton.setEnabled(True)
self.OpenFolder.setEnabled(True)
self.OpenFolder.setVisible(True)
self.animatedContainer.setVisible(False)
return
def AppendMovieTimeSheet(self):
global videosFolders
videosFolders = QFileDialog.getOpenFileName(None, "Select Videos", "",
"*.avi *.mp4 *.mov")
getVideoPath = map(str, videosFolders)
sanatizePath = 'removeme'.join(getVideoPath)
splitPath = sanatizePath.split('removeme')
extractString = map(str, splitPath[0])
readytoAppendPath = ''.join(extractString)
if readytoAppendPath != "":
AppendTimes = "00:00:00-00:00:00"
rowPosition = self.areaTabTable.rowCount()
self.areaTabTable.insertRow(rowPosition)
self.areaTabTable.setItem(rowPosition, 1,
QTableWidgetItem(AppendTimes))
self.areaTabTable.setItem(rowPosition, 0,
QTableWidgetItem(readytoAppendPath))
self.StartButton.setEnabled(True)
else:
print("Error Missing Data, No videos were Added")
def RemoveTable(self):
self.areaTabTable.removeRow(0)
def SaveCSVFile(self):
import csv
path = "movies.csv"
if path != '':
with open(path, 'w') as csv_file:
writer = csv.writer(csv_file, dialect='excel')
for row in range(self.areaTabTable.rowCount()):
row_data = []
for column in range(self.areaTabTable.columnCount()):
item = self.areaTabTable.item(row, column)
if item is not None:
row_data.append(item.text())
else:
row_data.append('')
writer.writerow(row_data)
self.Processing()
def SaveConfigurationVideo(self):
from configparser import ConfigParser
SetFps = self.Fps.text()
SetWidthVideo = self.WidthVideo.text()
SetHeightVideo = self.HeightVideo.text()
if SetFps and SetHeightVideo and SetWidthVideo != "":
config = ConfigParser()
config.add_section('Settings')
config.set('Settings', 'Height', SetHeightVideo)
config.set('Settings', 'Width', SetWidthVideo)
config.set('Settings', 'FPS', SetFps)
self.InfoText.setText("Saved Configuration!")
with open('CSettings.cfg', 'w') as configfile:
config.write(configfile)
configfile.close()
else:
QMessageBox.critical(None, "Mising Fields",
"Please Complete All Fields")
def retranslateUi(self, ScrollArea):
ScrollArea.setWindowTitle(
QCoreApplication.translate("ScrollArea",
u"ExtractAndMerge 0.1 Beta", None))
self.WidthVideo.setPlaceholderText(
QCoreApplication.translate("ScrollArea", u"Set Width", None))
self.HeightVideo.setPlaceholderText(
QCoreApplication.translate("ScrollArea", u"Set Height", None))
self.OpenFileFolder.setToolTip(
QCoreApplication.translate("ScrollArea", u"Add a Video", None))
self.SaveVideo.setToolTip(
QCoreApplication.translate("ScrollArea", u"Save Configuration",
None))
self.Fps.setPlaceholderText(
QCoreApplication.translate("ScrollArea", u"FPS: 25", None))
self.label_9.setText("")
self.label_10.setText("")
self.label_12.setText("")
self.OpenFileFolder.setText("")
#if QT_CONFIG(tooltip)
self.WidthVideo.setToolTip(
QCoreApplication.translate("ScrollArea", u"Set Width", None))
#endif // QT_CONFIG(tooltip)
self.WidthVideo.setText("")
self.SaveVideo.setText("")
#if QT_CONFIG(tooltip)
self.HeightVideo.setToolTip(
QCoreApplication.translate("ScrollArea", u"Set Height", None))
#endif // QT_CONFIG(tooltip)
self.HeightVideo.setText("")
#if QT_CONFIG(tooltip)
self.Fps.setToolTip(
QCoreApplication.translate("ScrollArea", u"FPS del Video", None))
#endif // QT_CONFIG(tooltip)
self.Fps.setText("")
#self.StartVideo.setText("")
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab), "")
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_2), "")
self.CloseX.setText(
QCoreApplication.translate("ScrollArea", u"X", None))
self.MinimizedWindow.setText(
QCoreApplication.translate("ScrollArea", u"_", None))
self.label_11.setText("")
self.Tagline.setText(
QCoreApplication.translate("ScrollArea",
u"ExtractAndMerge 0.1 Beta", None))
