def animationLabel(self, index, animationFile, speed=100):
"""
Public slot to set an animated icon.
@param index tab index (integer)
@param animationFile name of the file containing the animation (string)
@param speed animation speed of the icon in percent of the original
icon's speed (integer)
@return reference to the created label (QLabel)
"""
if index == -1:
return None
if hasattr(self.__tabBar, 'setTabButton'):
side = self.__freeSide()
animation = QLabel(self)
if animationFile and not animation.movie():
movie = QMovie(animationFile, QByteArray(), animation)
movie.setSpeed(speed)
animation.setMovie(movie)
movie.start()
self.__tabBar.setTabButton(index, side, None)
self.__tabBar.setTabButton(index, side, animation)
return animation
else:
return None
class StatusBarView(QStatusBar):
"""
The model of Navigation component
"""
def __init__(self, parent):
super().__init__(parent)
self.status_label = QLabel("", parent)
self.status_label.setTextFormat(Qt.RichText)
self.label_time = QLabel("", parent)
self.combo_referential = QComboBox(parent)
self.movie_loader = QMovie(":/icons/loader")
self.label_loading = QLabel(parent)
self.label_loading.setMovie(self.movie_loader)
self.label_loading.setMaximumHeight(self.height())
self.movie_loader.setScaledSize(QSize(16, 16))
self.movie_loader.start()
self.movie_loader.setPaused(True)
self.addPermanentWidget(self.label_loading)
self.addPermanentWidget(self.status_label, 2)
self.addPermanentWidget(self.label_time)
self.addPermanentWidget(self.combo_referential)
def start_loading(self):
self.movie_loader.setPaused(False)
def stop_loading(self):
self.movie_loader.setPaused(True)
class MoviePlayer(QWidget):
def __init__(self):
super(MoviePlayer, self).__init__()
self.setAttribute(Qt.WA_TranslucentBackground)
self.setWindowFlags(Qt.FramelessWindowHint)
self.movie = QMovie(self)
self.movieLabel = QLabel("No movie loaded")
self.movieLabel.setAlignment(Qt.AlignAbsolute)
self.movieLabel.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.mainLayout = QVBoxLayout()
self.mainLayout.addWidget(self.movieLabel)
self.setLayout(self.mainLayout)
#self.resize(400, 500)
self.movieLabel.setMovie(self.movie)
self.movie.setFileName('icon/gears.gif')
pos = kp.pos()
x = pos.x() - ((self.width()/2) - (kp.width()/2)) +220
y = pos.y() - ((self.height()/2) - (kp.height()/2)) +160
self.setGeometry(x,y, 400, 500)
self.movie.start()
class SystemTrayIcon(QSystemTrayIcon):
def __init__(self, parent):
super(SystemTrayIcon, self).__init__()
self.parent = parent
self.new_folder_window = NewFolderWindow(parent)
self.preferences_window = PreferencesWindow()
self.setIcon(QIcon(":gridsync.png"))
self.right_menu = RightClickMenu(self)
self.setContextMenu(self.right_menu)
self.activated.connect(self.on_click)
self.animation = QMovie()
self.animation.setFileName(":sync.gif")
self.animation.updated.connect(self.update_animation_frame)
self.animation.setCacheMode(True)
def update_animation_frame(self):
self.setIcon(QIcon(self.animation.currentPixmap()))
def set_icon(self, resource):
self.setIcon(QIcon(resource))
def on_click(self, value):
#self.right_menu.populate()
if value == QSystemTrayIcon.Trigger:
open_gridsync_folder()
def on_quit(self):
reactor.stop()
def initoptionspanel(self):
label = QLabel('Filter')
filtertype = QComboBox()
filtertype.addItem('None')
filtertype.addItem('Lowpass')
filtertype.addItem('Highpass')
filtertype.addItem('Bandreject')
filtertype.addItem('Bandpass')
filtertype.currentIndexChanged.connect(self.filtertypelistener)
self.filterfunction = QComboBox()
self.filterfunction.addItem('Ideal')
self.filterfunction.addItem('Butterworth')
self.filterfunction.addItem('Gaussian')
self.filterfunction.currentIndexChanged.connect(self.filterfunctionlistener)
self.filterfunction.setEnabled(False)
self.filtercutoff = QDoubleSpinBox()
self.filtercutoff.setValue(0.0)
self.filtercutoff.setRange(0.0, 10000.0)
self.filtercutoff.valueChanged.connect(self.filtercutofflistener)
self.filtercutoff.setEnabled(False)
self.filterbandwidth = QDoubleSpinBox()
self.filterbandwidth.setValue(1.0)
self.filterbandwidth.setRange(0.0, 10000.0)
self.filterbandwidth.valueChanged.connect(self.filterbandwidthlistener)
self.filterbandwidth.setEnabled(False)
self.filterorder = QDoubleSpinBox()
self.filterorder.setValue(1.0)
self.filterorder.setRange(0.0, 10000.0)
self.filterorder.valueChanged.connect(self.filterorderlistener)
self.filterorder.setEnabled(False)
loader = QMovie('loader.gif')
loader.start()
self.loadercontainer = QLabel()
self.loadercontainer.setMovie(loader)
self.loadercontainer.setVisible(False)
formlayout = QFormLayout()
formlayout.addRow('Type', filtertype)
formlayout.addRow('Function', self.filterfunction)
formlayout.addRow('Cut off', self.filtercutoff)
formlayout.addRow('Bandwidth', self.filterbandwidth)
formlayout.addRow('Order', self.filterorder)
formlayout.addRow('', self.loadercontainer)
filterbox = QGroupBox('Filter')
filterbox.setLayout(formlayout)
options = QDockWidget('Options')
options.setFeatures(QDockWidget.DockWidgetFloatable)
options.setFeatures(QDockWidget.DockWidgetMovable)
options.setWidget(filterbox)
self.addDockWidget(Qt.RightDockWidgetArea, options)
class LoadingGifWin( QWidget):
def __init__(self,parent=None):
super(LoadingGifWin, self).__init__(parent)
self.label = QLabel('', self)
self.setFixedSize(128,128)
self.setWindowFlags( Qt.Dialog| Qt.CustomizeWindowHint)
self.movie = QMovie("./images/loading.gif")
self.label.setMovie(self.movie)
self.movie.start()
def __makeAnimatedLabel(self, fileName, label):
"""
Private slot to create an animated label.
@param fileName name of the file containing the animation (string)
@param label reference to the label to be animated (QLabel)
"""
movie = QMovie(fileName, QByteArray(), label)
movie.setSpeed(100)
label.setMovie(movie)
movie.start()
class WaitDialog(QWidget):
def __init__(self, parent=None, *args, **kwargs):
super(WaitDialog, self).__init__(parent)
self.label = QLabel(self)
self.label.setAlignment(Qt.AlignCenter)
self.setFixedSize(551, 401)
self.setWindowOpacity(0.5) # set transparent
self.setWindowFlags(Qt.Dialog | Qt.CustomizeWindowHint | Qt.FramelessWindowHint)
self.setAttribute(Qt.WA_TranslucentBackground) # background transparent
self.setContentsMargins(0, 0, 0, 0)
config = Config()
self.movie = QMovie(os.path.join(config.images, 'wait.gif'))
self.label.setMovie(self.movie)
self.movie.start()
def __init__(self, parent=None):
super(MoviePlayer, self).__init__(parent)
self.movie = QMovie(self)
self.movie.setCacheMode(QMovie.CacheAll)
self.movieLabel = QLabel("No movie loaded")
self.movieLabel.setAlignment(Qt.AlignCenter)
self.movieLabel.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.movieLabel.setBackgroundRole(QPalette.Dark)
self.movieLabel.setAutoFillBackground(True)
self.currentMovieDirectory = ''
self.createControls()
self.createButtons()
self.movie.frameChanged.connect(self.updateFrameSlider)
self.movie.stateChanged.connect(self.updateButtons)
self.fitCheckBox.clicked.connect(self.fitToWindow)
self.frameSlider.valueChanged.connect(self.goToFrame)
self.speedSpinBox.valueChanged.connect(self.movie.setSpeed)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.movieLabel)
mainLayout.addLayout(self.controlsLayout)
mainLayout.addLayout(self.buttonsLayout)
self.setLayout(mainLayout)
self.updateFrameSlider()
self.updateButtons()
self.setWindowTitle("Movie Player")
self.resize(400, 400)
def __init__(self, parent=None):
super(XNCStatusBar, self).__init__(parent)
# state vars
self.world = XNovaWorld_instance()
# initialization
self.setSizeGripEnabled(True)
# sub-widgets
# progressbar
self._progressbar = QProgressBar(self)
self._progressbar.hide()
self._progressbar.setValue(0)
self._progressbar.setRange(0, 99)
# online players counter
self._lbl_online = QLabel(self.tr('Online') + ': 0', self)
# label with loading.gif
self._loading_gif = QMovie(':/i/loading.gif')
self._lbl_loading = QLabel(self)
self._lbl_loading.setMovie(self._loading_gif)
self._lbl_loading.hide()
# testing only
self._btn_runscript = QPushButton('Run script', self)
self._btn_runscript.clicked.connect(self.on_run_script)
self.addPermanentWidget(self._btn_runscript)
#
self.addPermanentWidget(self._lbl_loading)
self.addPermanentWidget(self._lbl_online) # should be las right widget
self.show()
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.searchEdit.textChanged.connect(self.search_text_changed)
self.ui.show_button.clicked.connect(self.show_episodes)
self.ui.searchEdit.returnPressed.connect(self.show_episodes)
self.episodes = None
self.episode_list = None
self.number = 0
self.anime_list = None
self.ui.download_button.clicked.connect(self.download)
self.ui.res_list_widget.currentItemChanged.connect(self.episode_change)
self.com = Comunicate()
self.com.sig.connect(self.message)
self.com.img.connect(self.set_image)
self.ui.anime_list_widget.itemDoubleClicked.connect(self.show_episodes)
self.setWindowIcon(QIcon(get_file('animes.png')))
self.ui.anime_list_widget.itemPressed.connect(self.anime_entered)
Thread(target=self.load_url_items).start()
#self.load_url_items()
self.movie = QMovie(get_file('ajax-loader.gif'))
self.ui.loading_label.setMovie(self.movie)
self.link = None
self.main_download_page = None
self.tray = SystemTrayIcon(
QIcon(get_file('animes.png')), self.com, self)
self.com.op.connect(self.show_semard)
self.ui.action_About_Semard.triggered.connect(self.about_semard)
self.ui.action_Contato.triggered.connect(self.show_feedback)
self.setWindowTitle('Semard - Animes')
self.browser = None
self.player = None
def setPath(self, path):
if hasattr(self, "_movie"):
self._movie.stop()
del self._movie
if not path:
return
self._movie = QMovie(path)
self.setMovie(self._movie)
self._movie.start()
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setGeometry(50, 50, 600, 750)
self.setFixedSize(500, 500)
self.startUIWindow()
self.movie = QMovie("mail.gif")
self.movie.frameChanged.connect(self.repaint)
self.movie.start()
def __init__(self, parent, text=""):
QDialog.__init__(self, parent)
# Create waiting image
waitingImage = QMovie(qtUtils.getAbsoluteImagePath('waiting.gif'))
waitingImage.start()
waitingImageLabel = QLabel(self)
waitingImageLabel.setMovie(waitingImage)
waitingLabel = QLabel(text, self)
hbox = QHBoxLayout()
hbox.addStretch(1)
hbox.addWidget(waitingImageLabel)
hbox.addSpacing(10)
hbox.addWidget(waitingLabel)
hbox.addStretch(1)
self.setLayout(hbox)
class LoadingItem(QLabel):
def __init__(self):
super(LoadingItem, self).__init__()
self.movie = QMovie(resources.IMAGES['loading'])
self.setMovie(self.movie)
self.movie.setScaledSize(QSize(16, 16))
self.movie.start()
def add_item_to_tree(self, folder, tree, item_type=None, parent=None):
if item_type is None:
item = QTreeWidgetItem()
item.setText(0, (_translate("LoadingItem", " LOADING: '%s'") % folder))
else:
item = item_type(parent, (
_translate("LoadingItem", " LOADING: '%s'") % folder), folder)
tree.addTopLevelItem(item)
tree.setItemWidget(item, 0, self)
return item
def setFile(self, file):
self.file = file
if file.lower().endswith('.gif'):
self.movie = QMovie(file)
self.widget().setMovie(self.movie)
self.movie.finished.connect(self.movie.start)
self.movie.start()
else:
self.movie = None
self.originalPixmap = QPixmap(file)
self._rebuildZoom()
def open(self):
self.file = QFileDialog.getOpenFileName(self, "Open File", self.pwd)[0]
if self.file == "":
return
self.information = info.Information(self, self.file)
movie = QMovie(self.file, QByteArray(), self)
movie.setCacheMode(QMovie.CacheAll)
movie.setSpeed(100)
self.label.setMovie(movie)
movie.start()
def load_ui(self):
self.ui = uic.loadUi(self.uifile, self)
self.ui.lbl_loading.hide()
self.ui.btn_login.clicked.connect(self.on_btn_login)
self.ui.btn_register.clicked.connect(self.on_btn_register)
self.loading_gif = QMovie(':/i/loading.gif')
self.restore_login()
# load xnova url from config/net.ini
cfg = configparser.ConfigParser()
cfg.read('config/net.ini', encoding='utf-8')
if 'net' in cfg:
self.xnova_url = cfg['net']['xnova_url']
def __init__(self, tray, interval = 100):
self.tray = tray
self.movie = QMovie(":/images/tray_animations/tray.gif")
self.movie.setSpeed(interval)
self.movie.frameChanged.connect(self.next_icon)
self.icons = Enum(
ok = QIcon(":/images/demerio.png"),
problem = QIcon(":/images/demerio-problem.png"),
conductor_problem = QIcon(":/images/demerio-conductor-problem.png")
)
self.icon = self.icons.ok
self.update_icon()
class GifWidget(QLabel):
def __init__(self, parent = None, path = None):
super(GifWidget, self).__init__(parent)
self.setPath(path)
def __del__(self):
print("GifWidget __del__")
if hasattr(self, "_movie"):
self._movie.stop()
del self._movie
def setPath(self, path):
if hasattr(self, "_movie"):
self._movie.stop()
del self._movie
if not path:
return
self._movie = QMovie(path)
self.setMovie(self._movie)
self._movie.start()
def start(self):
if hasattr(self, "_movie"):
self._movie.start()
def stop(self):
if hasattr(self, "_movie"):
self._movie.stop()
def setupWidget1(self):
#setup the tree
movie = QMovie()
movie.setFileName("res/tree.gif")
self.ui.lb_tree.setMovie(movie)
self.ui.lb_tree_big.setMovie(movie)
movie.start()
#setup the statistics
self.ui.gridLayout.setHorizontalSpacing(60)
self.ui.gridLayout.setVerticalSpacing(10)
self.ui.gridLayout.setGeometry(QRect(0, 51, 291, 224))
self.ui.gridLayout.setAlignment(QtCore.Qt.AlignCenter)
self.statLabels = []
for i in range(7):
self.statLabels.append([])
for j in range(4):
self.statLabels[i].append(QLabel())
self.statLabels[i][j].setScaledContents(True)
self.statLabels[i][j].setAutoFillBackground(False)
self.statLabels[i][j].setAlignment(QtCore.Qt.AlignCenter)
self.ui.gridLayout.addWidget(self.statLabels[i][j], i, j, 1, 1)
class IconManagement(object):
def __init__(self, tray, interval = 100):
self.tray = tray
self.movie = QMovie(":/images/tray_animations/tray.gif")
self.movie.setSpeed(interval)
self.movie.frameChanged.connect(self.next_icon)
self.icons = Enum(
ok = QIcon(":/images/demerio.png"),
problem = QIcon(":/images/demerio-problem.png"),
conductor_problem = QIcon(":/images/demerio-conductor-problem.png")
)
self.icon = self.icons.ok
self.update_icon()
def internet_is_ok(self, internet_is_ok):
self.icon = self.icons.ok if internet_is_ok else self.icons.problem
self.update_icon()
@pyqtSlot(int)
def next_icon(self, i):
self.tray.setIcon(QIcon(self.movie.currentPixmap()))
def start(self):
self.movie.start()
def stop(self):
self.update_icon()
self.movie.stop()
def update_icon(self):
self.tray.setIcon(self.icon)
def conductor_problem(self):
if self.movie.state() == QMovie.Running:
self.movie.stop()
self.icon = self.icons.conductor_problem
self.update_icon()
class MainWindow(QMainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setGeometry(50, 50, 600, 750)
self.setFixedSize(500, 500)
self.startUIWindow()
self.movie = QMovie("mail.gif")
self.movie.frameChanged.connect(self.repaint)
self.movie.start()
def startUIWindow(self):
self.Window = UIWindow(self)
self.setWindowTitle("Email Dialog")
self.show()
def paintEvent(self, event):
currentFrame = self.movie.currentPixmap()
frameRect = currentFrame.rect()
frameRect.moveCenter(self.rect().center())
if frameRect.intersects(event.rect()):
painter = QPainter(self)
painter.drawPixmap(frameRect.left(), frameRect.top(), currentFrame)
class QConnectingWidget(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
# Create connecting image
self.connectingGif = QMovie(qtUtils.getAbsoluteImagePath('waiting.gif'))
self.connectingGif.start()
self.connetingImageLabel = QLabel(self)
self.connetingImageLabel.setMovie(self.connectingGif)
self.connectingLabel = QLabel(self)
hbox = QHBoxLayout()
hbox.addStretch(1)
hbox.addWidget(self.connetingImageLabel, alignment=Qt.AlignCenter)
hbox.addSpacing(10)
hbox.addWidget(self.connectingLabel, alignment=Qt.AlignCenter)
hbox.addStretch(1)
self.setLayout(hbox)
def setConnectingToNick(self, nick):
self.connectingLabel.setText("Connecting to " + nick + "...")
def __init__(self):
QWidget.__init__(self, ctx.mainScreen)
self.setObjectName("InformationWindow")
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.setFixedHeight(50)
self.setMaximumWidth(800)
self.setStyleSheet("""
QFrame#frame { border: 1px solid rgba(255,255,255,30);
/*border-radius: 4px;*/
background-color: rgba(0,0,0,100);}
QLabel { border:none;
color:#FFFFFF;}
QProgressBar { border: 1px solid white;}
QProgressBar::chunk { background-color: #F1610D;
width: 0.5px;}
""")
self.gridlayout = QGridLayout(self)
self.frame = QFrame(self)
self.frame.setObjectName("frame")
self.horizontalLayout = QHBoxLayout(self.frame)
self.horizontalLayout.setContentsMargins(10, 0, 10, 0)
# Spinner
self.spinner = QLabel(self.frame)
self.spinner.setMinimumSize(QSize(16, 16))
self.spinner.setMaximumSize(QSize(16, 16))
self.spinner.setIndent(6)
self.movie = QMovie(':/images/working.mng')
self.spinner.setMovie(self.movie)
self.movie.start()
self.horizontalLayout.addWidget(self.spinner)
# Message
self.label = QLabel(self.frame)
self.label.setAlignment(Qt.AlignCenter)
self.label.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.icon = QLabel(self.frame)
self.icon.setFixedWidth(16)
self.icon.setFixedHeight(16)
self.horizontalLayout.setSpacing(10)
self.horizontalLayout.addWidget(self.icon)
self.horizontalLayout.addWidget(self.label)
self.gridlayout.addWidget(self.frame,0,0,1,1)
def _onInstallButtonClicked(self):
"""Handler for install button"""
url = self._pluginEntry["download"]
tmpName = str(uuid.uuid4()) + ".zip"
self._downloadPath = os.path.join(TMP, tmpName)
downloadThread = DownloadPluginThread(url, self._downloadPath)
downloadThread.success.connect(self._onDownloadSuccess)
downloadThread.failed.connect(self._onDownloadFailed)
downloadThread.start()
self._spinner = QMovie(SPINNER_ICON_PATH)
self._spinner.frameChanged.connect(self._setInstallButtonIcon)
self._spinner.start()
self.installButton.setText("Installing...")
self.installButton.setDisabled(True)
def __init__(self, parent):
super(SystemTrayIcon, self).__init__()
self.parent = parent
self.new_folder_window = NewFolderWindow(parent)
self.preferences_window = PreferencesWindow()
self.setIcon(QIcon(":gridsync.png"))
self.right_menu = RightClickMenu(self)
self.setContextMenu(self.right_menu)
self.activated.connect(self.on_click)
self.animation = QMovie()
self.animation.setFileName(":sync.gif")
self.animation.updated.connect(self.update_animation_frame)
self.animation.setCacheMode(True)
def mostrarDispositivos(self, index):
self.ScrollContainer.setGeometry(QtCore.QRect(5, 45, 660, 470))
for ui in self.UIContainer:
ui.close()
self.UIContainer.clear()
QtWidgets.QApplication.processEvents()
container = self.comboBox.itemData(index)
if len(container.workSpace.devices) == 0:
self.UtilsFrame.show()
self.updateState("¡Vacio! Aqui no hay nada",
QMovie(":/source/img/Empty.png"), True)
return
else:
self.UtilsFrame.hide()
for d in container.workSpace.devices:
self.mostrarDispositivoAction(d)
if len(container.workSpace.devices) * 200 > 399:
self.ScrollContainer.setGeometry(
QtCore.QRect(5, 45, 660,
(len(container.workSpace.devices) * 200) + 35))
class LoadingWidget(QLabel):
def __init__(self, *args, **kwargs):
super(LoadingWidget, self).__init__(*args, **kwargs)
self.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self._movie = QMovie("loading.gif")
self.setMovie(self._movie)
def deleteLater(self):
self._movie.stop()
self._movie.deleteLater()
del self._movie
super(LoadingWidget, self).deleteLater()
def show(self):
self.setVisible(True)
super(LoadingWidget, self).show()
self._movie.start()
def closeEvent(self, event):
self._movie.stop()
self.setVisible(False)
super(LoadingWidget, self).closeEvent(event)
def __init__(self, parent):
super().__init__(parent)
self.status_label = QLabel("", parent)
self.status_label.setTextFormat(Qt.RichText)
self.label_time = QLabel("", parent)
self.combo_referential = QComboBox(parent)
self.movie_loader = QMovie(":/icons/loader")
self.label_loading = QLabel(parent)
self.label_loading.setMovie(self.movie_loader)
self.label_loading.setMaximumHeight(self.height())
self.movie_loader.setScaledSize(QSize(16, 16))
self.movie_loader.start()
self.movie_loader.setPaused(True)
self.addPermanentWidget(self.label_loading)
self.addPermanentWidget(self.status_label, 2)
self.addPermanentWidget(self.label_time)
self.addPermanentWidget(self.combo_referential)
def __init__(self, file, width, height, padding_x=0, padding_y=0, parent=None):
super().__init__(parent)
self.setFixedSize(width + 2*padding_x, height + 2*padding_y)
layout = QVBoxLayout()
layout.setSpacing(0)
layout.setContentsMargins(*(padding_x, padding_y)*2)
label = QLabel()
label.setFixedSize(width, height)
self._movie = movie = QMovie(file, QByteArray(), self)
movie.setCacheMode(QMovie.CacheAll)
movie.setSpeed(120)
movie.start()
label.setMovie(movie)
layout.addWidget(label)
self.setLayout(layout)
def mostrarDispositivos(self,index):
self.ScrollContainer.setGeometry(QtCore.QRect(0, 0, 660, 470))
for ui in self.UIContainer:
ui.close()
self.UIContainer.clear()
QtWidgets.QApplication.processEvents()
workSpace = self.comboBox.itemData(index)
if len(workSpace.devices) == 0:
self.UtilsFrame.show()
self.updateState("¡Vacio! Aqui no hay nada",QMovie(":/source/img/Empty.png"),True)
return
else:
self.UtilsFrame.hide()
for d in workSpace.devices:
UI = UIDispositivoModalWidget(d,True)
self.verticalLayout_3.addWidget(UI,0,QtCore.Qt.AlignTop | QtCore.Qt.AlignHCenter)
UI.signals.edit.connect(self.success) # signal indicates is import not edit really
self.UIContainer.append(UI)
if len(workSpace.devices)*200 > 399:
self.ScrollContainer.setGeometry(QtCore.QRect(5,45,660,(len(workSpace.devices)*200)+35))
async def _doDownloadImage(self, url):
# 下载图片并添加到界面
async with self.session.get(url) as resp:
data = await resp.read()
if not data:
print('下载失败: ', url)
return
path = os.path.join('tmp', os.path.basename(url))
with open(path, 'wb') as fp:
fp.write(data)
item = QListWidgetItem(url, self.listWidget)
image = QPixmap(path)
item.setSizeHint(image.size())
label = QLabel(self.listWidget)
label.setPixmap(image)
if path.endswith('.gif'): # 可能是动态图
label.setMovie(QMovie(path))
self.listWidget.setItemWidget(item, label)
self.listWidget.scrollToBottom()
def initAppearance(self):
# 设置图标
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap("resource/imgs/logo.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.setWindowIcon(icon)
# 设置标题
self.setWindowTitle('关于 ' + R.string.APP_NAME)
# 设置版本号
self.aboutForm.lblVersion.setText(R.string.VERSION)
# 设置logo
pix = QPixmap('resource/imgs/logo.png')
self.aboutForm.logo.setPixmap(pix)
self.aboutForm.logo.setScaledContents(True)
# 设置动图
movie1 = QMovie('resource/imgs/gif1.gif')
movie2 = QMovie('resource/imgs/gif2.gif')
self.aboutForm.gif_1.setMovie(movie1)
self.aboutForm.gif_2.setMovie(movie2)
self.aboutForm.gif_1.setScaledContents(True)
self.aboutForm.gif_2.setScaledContents(True)
movie1.start()
movie2.start()
def learning_step_1(self):
self.tittle = "Исследование 3D печати"
self.setWindowTitle(self.tittle + " - начало")
self.label.clear()
self.label_2.clear()
self.pushButton_Skip.clicked.connect(self.close)
self.pushButton_Back.hide()
self.pushButton_Next.setText("Далее")
self.pushButton_Next.clicked.connect(self.learning_step_2)
self.label_infoStepCount.setText("Начало")
self.label.setPixmap(
QPixmap("img/learn/slide1/slide1.png").scaledToWidth(940))
self.label_2.show()
self.label.setFixedHeight(440)
movie1 = QMovie("img/learn/slide1/fdm_1.gif")
self.label_2.setMovie(movie1)
movie1.start()
self.label_3.show()
movie2 = QMovie("img/learn/slide1/sla_2.gif")
self.label_3.setMovie(movie2)
movie2.start()
def getQMovie(self):
"""
Returns: Qmovie object containing the animation.
"""
if not self.contents == "animation":
return None
if self.qdata is None and not self.error:
root, file = self.path
img = QMovie(os.path.join(root, file))
if not img.isValid():
self.error = "failed to load: " + img.lastError()
return None
img.setScaledSize(QSize(*self.fullsize))
self.qdata = img
return self.qdata
def ShowGameReport(self):
# clear the right side of the window and then construct it again
try:
self.right_scroll_area.deleteLater()
except Exception:
pass
self.right_scroll_area = QScrollArea()
self.right_scroll_widget = QWidget()
self.right_scroll_widget.setMinimumSize(800, 350 * len(self.game_report_content))
scroll_layout = QVBoxLayout()
scroll_layout.setAlignment(Qt.AlignHCenter)
self.right_scroll_widget.setLayout(scroll_layout)
self.right_scroll_area.setWidget(self.right_scroll_widget)
self.right_layout.addWidget(self.right_scroll_area)
# put items to the right side of the window
right_label = [QLabel() for i in range(len(self.game_report_content))]
for idx, item in enumerate(self.game_report_content):
if item is 'gif':
gif = QMovie("temp_gif/{}.gif".format(idx))
gif.setSpeed(125)
# the speed of gif needs some fine tuning, 125 means 1.25 times original speed
# the speed gets slower when using original speed
gif.setScaledSize(QSize(600, 357))
right_label[idx].setMovie(gif)
gif.start()
elif item is 0:
# this might happen when there's an advertisement image, see method GetNewsDetails
continue
else:
right_label[idx].setText(item)
right_label[idx].setFont(QFont("Microsoft YaHei", 12))
right_label[idx].setWordWrap(True)
right_label[idx].setAlignment(Qt.AlignCenter)
scroll_layout.addWidget(right_label[idx])
scroll_layout.addStretch(1)
class QLoadingDialog(QDialog):
def __init__(self, parent=None):
super(QLoadingDialog, self).__init__()
self.setFixedSize(100, 100)
# self.setWindowOpacity(0.8)
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground)
app = QApplication.instance()
curr_theme = "light"
if app:
curr_theme = app.property("theme")
gif_file = os.path.abspath(
"./assets/icons/{}/loading.gif".format(curr_theme))
self.movie = QMovie(gif_file)
self.label = QLabel()
self.label.setMovie(self.movie)
self.layout = QVBoxLayout(self)
self.layout.addWidget(self.label)
def center(self, host: QWidget = None):
if host:
hostGeometry: QRect = host.geometry()
# dialogGeometry : QRect = self.geometry()
centerPoint: QPoint = hostGeometry.center()
centerPoint = host.mapToGlobal(centerPoint)
offset = 30
targetPoint = QPoint(centerPoint.x() - offset,
centerPoint.y() - offset)
self.move(targetPoint)
else:
screen = QApplication.desktop().screenNumber(
QApplication.desktop().cursor().pos())
centerPoint = QApplication.desktop().screenGeometry(
screen).center()
self.move(centerPoint)
return self
def showEvent(self, e: QShowEvent):
if self.movie.state() == QMovie.NotRunning:
self.movie.start()
def closeEvent(self, e: QCloseEvent):
if self.movie.state() == QMovie.Running:
self.movie.stop()
def exec_(self):
self.center()
return QDialog.exec_(self)
class PopupExpulsar(QWidget):
"""
Popup mostrado al expulsar un jugador de la nave
"""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.image_size = (480, 270)
self.__init_ui()
self.__connect_events()
self.__retranslate_ui()
def __init_ui(self):
# Main widget declaration
self.gif_label = QLabel(self)
self.setMinimumSize(*(self.image_size))
# Text
self.text_label = QLabel(self)
# Add to layout
self.main_vertical_layout = QVBoxLayout(self)
self.main_vertical_layout.addStretch(1)
self.main_vertical_layout.addWidget(self.text_label)
self.main_vertical_layout.addStretch(3)
def __retranslate_ui(self):
self.setWindowTitle("DCCrew DemoCratiCa - Ejection")
# Text
self.text_label.setStyleSheet("""
color: white;
font-size: 28px;
""")
self.text_label.setFont(QFont("Helvetica"))
self.text_label.setAlignment(Qt.AlignCenter)
# Gif
path_gif = path.join("assets", "expulsado.gif")
self.gif = QMovie(path_gif)
self.gif.setSpeed(200)
self.gif.setScaledSize(QSize(*self.image_size))
self.gif_label.setMovie(self.gif)
self.gif_label.setMinimumSize(QSize(*(self.image_size)))
def __connect_events(self):
pass
def actualizar_label(self, username):
self.text_label.setText(f"{username} ha sido expulsado...")
self.gif.start()
def add_gif(self, data):
if data['error']:
self.gif_data_frame.show()
self.scroll.hide()
self.info_label.show()
return
row, col, error, file_name = data.values()
movie = QMovie(file_name)
movie.setSpeed(200)
label_gif = QLabel()
label_gif.setMovie(movie)
movie.start()
self.gifs_layout.addWidget(label_gif, row, col)
label_gif.show()
def getAlarm(self):
self.alarm_layout = QGridLayout()
self.movie = QMovie(self.parent.os_path + "/img/giphy2.gif", QByteArray(), self)
self.movie_screen = QLabel()
# Make label fit the gif
self.movie_screen.setFixedSize(80, 50)
# Add the QMovie object to the label
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
self.movie_screen.setMovie(self.movie)
self.movie.start()
self.timeout_ack = []
self.dialog = self.dialogTimeout()
self.dialog.hide()
self.label_acq = QPushButton("ACQUISITION")
self.label_acq.clicked.connect(self.dialog.show)
self.label_acq.setFixedHeight(50)
self.setColor("QPushButton", self.label_acq, "green")
self.alarm_layout.addWidget(self.movie_screen, 0, 0, 1, 1)
self.alarm_layout.addWidget(self.label_acq, 0, 1, 1, 2)
for i, device in enumerate(self.list_alarm):
name = device["tableName"] + device["key"]
button = QPushButton(device["label"].upper())
button.setFixedHeight(50)
self.setColor("QPushButton", button, "green")
button.clicked.connect(partial(self.showWarning, "msg_%s" % name))
self.alarm_layout.addWidget(button, 0, i + 3, 1, 1)
setattr(self, "alarm_%s" % name, button)
self.watcher_alarm = QTimer(self)
self.watcher_alarm.setInterval(5000)
self.watcher_alarm.timeout.connect(self.checkCriticalValue)
self.watcher_alarm.start()
def __init__(self,
name,
notifier,
artPath,
link,
sound=None,
*args,
**kwargs):
'''- name : a string
- notifier : a Notifier object used to manage this notification
- artPath : a string containing the path to the image file to be displayed
- link : a string containing the link to be opened when left-clicking the notification
- sound : a string containing the path to the object or None. Set to None for silent notifiations.'''
super().__init__(*args, **kwargs)
self.setCursor(QCursor(Qt.PointingHandCursor))
self.name = name
self.notifier = notifier
self.link = link
self.artPath = artPath
self.isMovie = self.artPath.endswith(".gif")
if sound == None:
self.sound = None
else:
self.sound = QSoundEffect()
self.sound.setSource(QUrl.fromLocalFile(sound))
self.setWindowFlags(Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint
| Qt.Tool)
self.setAttribute(Qt.WA_TranslucentBackground)
imageLabel = QLabel()
self.setCentralWidget(imageLabel)
if self.isMovie:
self.art = QMovie(self.artPath)
self.art.jumpToNextFrame()
imageLabel.setMovie(self.art)
self.moveToBottomRight(self.art.frameRect().width(),
self.art.frameRect().height())
else:
self.art = QPixmap(self.artPath)
imageLabel.setPixmap(self.art)
self.moveToBottomRight(self.art.width(), self.art.height())
def generate_gif(self):
img: Image
imgs: List[Image]
# https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html#gif
select_frames_labels = self.layout_children(self.select_frames_layout)
if not select_frames_labels:
self.adjust_corgo()
return
pixmaps = [
i.original_pixmap for i in select_frames_labels if i.highlighted
]
height = int(self.height.text())
img, *imgs = [
qpixmap_to_pil(i.scaledToHeight(height)) for i in pixmaps
]
delay = int(self.delay.text())
bytesio = io.BytesIO()
img.save(fp=bytesio,
format='GIF',
append_images=imgs,
save_all=True,
duration=delay,
loop=0)
self.gif_qbytearray = QByteArray(bytesio.getvalue())
bytesio.close()
self.gif_qbuffer = QBuffer(self.gif_qbytearray)
gif = QMovie()
gif.setDevice(self.gif_qbuffer)
gif.setCacheMode(QMovie.CacheAll)
print(f'Movie isValid() {gif.isValid()}')
self.gif_view.setMovie(gif)
gif.start()
class OCCMovie(dispocc):
def __init__(self, disp=True, touch=True):
super().__init__(disp=disp, touch=touch)
self.MovieMenu()
def MovieMenu(self):
self.add_menu("Movie")
self.add_function("Movie", self.export_cap)
self.add_function("Movie", self.movie_start)
self.add_function("Movie", self.movie_stop)
def movie_start(self):
"""sart animnation"""
# use an animated gif file you have in the working folder
# or give the full file path
self.movie = QMovie(self.tempname + ".gif", QByteArray(), self.wi)
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
# self.movie_screen.setMovie(self.movie)
self.movie.start()
def movie_stop(self):
"""stop the animation"""
self.movie.stop()
class Canvas(QWidget):
def __init__(self):
super().__init__()
self.image = QImage()
self.movie = QMovie()
def play_gif(self, gif_url):
self.movie = QMovie(gif_url, QByteArray(), self)
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.start()
self.movie.loopCount()
def paintEvent(self, event):
qp = QPainter(self)
if not self.image.isNull():
image = self.image.scaled(self.size())
qp.drawImage(0, 0, image)
def __init__(self, cover_path, cover_title, video_path, video_hash, *args, **kwargs):
super(CoverLabel, self).__init__(*args, **kwargs)
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.rightMenuShow) # 开放右键策略
self.setCursor(Qt.PointingHandCursor)
self.cover_path = cover_path
# self.setScaledContents(True)
# self.setMinimumSize(Const.GL_image_weight, Const.GL_image_height)
# self.setMaximumSize(Const.GL_image_weight, Const.GL_image_height)
self.video_hash = video_hash
self.cover_title = cover_title
self.video_path = video_path
if not (os.path.exists(cover_path)):
print("the img is not exist : "+cover_path)
cover_path = "cache/coverimg/default.jpg"
img = Image.open("cache/coverimg/default.jpg")
try:
img = Image.open(cover_path)
except Exception as e:
print("图片已损坏 : "+str(e))
os.remove(cover_path)
# 将下载状态置为1
sql = "UPDATE video SET is_download = ? WHERE hash = ?"
SqlUtils.update_video(sql, (1,video_hash))
cover_path = "cache/coverimg/default.jpg"
img_height = Const.GL_image_weight / img.size[0] * img.size[1]
if cover_path.endswith('.gif'):
movie = QMovie(cover_path)
# movie.setScaledSize(self.size())
movie.setScaledSize(QSize(Const.GL_image_weight, img_height))
self.setMinimumSize(Const.GL_image_weight, img_height)
self.setMaximumSize(Const.GL_image_weight, img_height)
# self.parent().setMaximumSize(GL_widget_weight, img_height+100)
# self.parent().setMaximumSize(GL_widget_weight, img_height+100)
self.parent().setFixedWidth(Const.GL_widget_weight)
self.setMovie(movie)
movie.start()
else:
cover_img = QPixmap(cover_path)
self.setPixmap(cover_img.scaled(Const.GL_image_weight, img_height))
self.setMinimumSize(Const.GL_image_weight, img_height)
self.setMaximumSize(Const.GL_image_weight, img_height)
# self.parent().setMaximumSize(GL_widget_weight, img_height+100)
# self.parent().setMaximumSize(GL_widget_weight, img_height+100)
self.parent().setFixedWidth(Const.GL_widget_weight)
def mostrarUsuarios(self, index):
self.ScrollContainer.setGeometry(QtCore.QRect(5, 65, 660, 451))
self.cleanUI()
filter = self.cmbTipo.currentText()
if not filter == "Todos":
filterUsr = list(self.filter(filter))
else:
filterUsr = self.usuarios
if len(filterUsr) == 0:
self.UtilsFrame.show()
self.updateState("¡Vacio! No hay usuario de este tipo",
QMovie(":/source/img/Empty.png"), True)
return
else:
self.UtilsFrame.hide()
for usr in filterUsr:
UIUsuario = UIUsuarioWidget(usr)
UIUsuario.signals.enable.connect(self.habilitarUsuario)
UIUsuario.signals.disable.connect(self.deshabilitarUsuario)
UIUsuario.signals.edit.connect(self.editarUsuario)
UIUsuario.signals.delete.connect(self.eliminarUsuario)
self.verticalLayout_3.addWidget(UIUsuario, 0,
Qt.AlignTop | Qt.AlignHCenter)
self.UIContainer[usr.id] = UIUsuario
def openFile(self, filepath=False):
if not filepath :
filefilter = "Image files (*.jpg *.png *.jpeg *.svg *.gif *.tiff *.ppm *.bmp);;JPEG Images (*.jpg *.jpeg);;PNG Images (*.png);;SVG Images (*.svg);;All Files (*)"
filepath, sel_filter = QFileDialog.getOpenFileName(self, 'Open Image', self.filepath, filefilter)
if filepath == '' : return
image_reader = QImageReader(filepath)
if image_reader.format() == 'gif': # For gif animations
anim = QMovie(filepath)
self.image.setAnimation(anim)
self.adjustWindowSize(True)
self.statusbar.showMessage("Resolution : %ix%i" % (self.image.width(), self.image.height()))
self.disableButtons(True)
else: # For static images
image_reader.setAutoTransform(True)
pm = QPixmap.fromImageReader(image_reader)
if not pm.isNull() :
self.image.scale = self.getOptimumScale(pm)
self.image.setImage(pm)
self.adjustWindowSize()
self.disableButtons(False)
else:
return
self.filepath = filepath
self.setWindowTitle(QFileInfo(filepath).fileName())
class _Loading(QSplashScreen):
"""A splashscreen to show while loading TensorFlow."""
def __init__(self):
"""Class constructor. Loads a gif to show while loading."""
path = os.path.join('res', 'loading', 'loading.gif')
self._gif = QMovie(path)
self._gif.jumpToFrame(0)
super().__init__(self._gif.currentPixmap(), Qt.WindowStaysOnTopHint)
self.showMessage('Loading, please wait...', color=Qt.yellow)
self._gif.frameChanged.connect(self._update)
self.setFixedSize(self.pixmap().size())
self._gif.start()
self.show()
def mousePressEvent(self, event: QMouseEvent):
"""Override the method so the splashscreen won't go away by clicking."""
def _update(self):
self.setPixmap(self._gif.currentPixmap())
class Loading(QWidget):
def __init__(self):
QWidget.__init__(self)
self.setup_ui()
def setup_ui(self):
self.movie = QMovie('assets\\load.gif')
gu = ctypes.windll.user32
self.setWindowFlags(Qt.FramelessWindowHint)
if int(open('Assets\\scaling.txt', mode='r').read()) == 0:
# self.setGeometry(gu.GetSystemMetrics(0) / 2 - 300 / 2, gu.GetSystemMetrics(1) / 2 - 300 / 2, 300, 300)
self.setGeometry(
QtCore.QRect(
gu.GetSystemMetrics(0) / 2 - 300 / 2,
gu.GetSystemMetrics(1) / 2 - 300 / 2, 300, 300))
else:
self.setGeometry(500, 500, 300, 300)
self.lbl = QLabel()
self.setStyleSheet("QLabel\n"
"{\n"
" background-color: #D7CCC8;\n"
"}\n")
self.lbl.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.lbl.setAlignment(Qt.AlignCenter)
main_layout = QVBoxLayout()
main_layout.addWidget(self.lbl)
self.setLayout(main_layout)
self.movie.setCacheMode(QMovie.CacheAll)
self.lbl.setMovie(self.movie)
self.movie.start()
self.movie.loopCount()
def start_dialog(self):
self.setWindowFlags(Qt.WindowStaysOnTopHint)
self.setWindowFlags(Qt.FramelessWindowHint)
self.show()
def stop_dialog(self):
self.hide()
def setPath(self, path=None):
if not path:
path = self.imagePathEdit.text()
if path.endswith(".png"):
self.label.setFixedWidth(800)
else:
self.label.setFixedSize(300, 300)
self.imagePathEdit.setText(path)
if os.path.exists(path):
if path.endswith(".gif"):
# print(path)
gif = QMovie(path)
gif.setScaledSize(QSize(300, 300))
self.label.setMovie(gif)
gif.start()
else:
image = QtGui.QPixmap(path).scaled(self.label.width(), self.label.height(), Qt.KeepAspectRatio)
self.label.setPixmap(image)
def UpdateTenSecs(self):
# do a UI update if its necessary
if self.which_movie == 'RK':
self.movie = QMovie(':/screen_saver/resources/UIBJ.gif')
self.ui.gifLabel.setMovie(self.movie)
self.movie.start()
self.which_movie = 'UIBJ'
elif self.which_movie == 'UIBJ':
self.movie = QMovie(':/screen_saver/resources/1LFE.gif')
self.ui.gifLabel.setMovie(self.movie)
self.movie.start()
self.which_movie = '1LFE'
elif self.which_movie == '1LFE':
self.movie = QMovie(':/screen_saver/resources/Rk69.gif')
self.ui.gifLabel.setMovie(self.movie)
self.movie.start()
self.which_movie = 'RK'
def show_image(self, row, column):
imageId = self.imageListTable.item(row, 0).text()
# set new active image id
self.active_image_id = imageId
# Removes a video from screen if shown:
self.videoPlayer.stop()
self.videoField.hide()
# show active image
self.show_active_image()
# show image and additional data
self.imageNameField.setText(f"{IMAGE_PATH_DICT[imageId]['name']}")
self.imageParamsField.setText(
f"HxW: {IMAGE_PATH_DICT[imageId]['additional_attrs']['height']}px"
+ f" x {IMAGE_PATH_DICT[imageId]['additional_attrs']['width']}px")
# Shows animated images
if IMAGE_PATH_DICT[imageId]["name"].lower().endswith("gif"):
gif = QMovie(IMAGE_PATH_DICT[imageId]["full_path"])
gifSize = QSize(*self.smooth_gif_resize(
IMAGE_PATH_DICT[imageId]["full_path"], 600, 600))
gif.setScaledSize(gifSize)
self.imageField.setMovie(gif)
gif.start()
# Shows static images
else:
self.imageField.setPixmap(
QPixmap(IMAGE_PATH_DICT[imageId]["full_path"]).scaled(
600, 600, Qt.KeepAspectRatio, Qt.SmoothTransformation))
if column == self.COLUMNS_DICT["Dup"]["index"]:
self.duplicateWindow = DuplicateWindow(
image_data=IMAGE_PATH_DICT[imageId], raw_id=imageId)
if imageId not in self.duplicateRefs.keys():
self.duplicateRefs[imageId] = self.duplicateWindow
self.duplicateWindow.show()
self.duplicateWindow.closeTrigger.connect(self.delete_reference)
def __init__(self):
print("start splash")
super().__init__()
if getattr(sys, 'frozen', False):
ui = 'login_Form.ui'
loadUi(resource_path(ui), self)
movie = QMovie(resource_path("loading.gif"))
else:
ui = 'Modules/UserInterface/login_Form.ui'
loadUi(ui, self)
movie = QMovie("Modules/UserInterface/loading.gif")
self.setFixedSize(340, 450)
self.logoIMG.setMovie(movie)
movie.start()
self.update_loading("Loading: Graphical User Interface")
print("loading main form")
self.task = Loading(self.labelLoad)
self.task.progress.connect(self.setMainForm)
self.task.finished.connect(self.openMainForm)
self.task.start()
self.setWindowFlags(Qt.Window | Qt.FramelessWindowHint)
self.show()
def jugador_golpeado(self, vida):
# Movimiento
paso = (self.enemigo.x() - self.jugador.x() - 300) / 5
for _ in range(5):
self.enemigo.move(self.enemigo.x() - paso, self.enemigo.y())
self.sleep(0.04)
# Animacion
gif_combo = QMovie(self.rutas["enemigo_golpea"])
gif_combo.setSpeed(200)
self.enemigo.setMovie(gif_combo)
self.enemigo.setFixedSize(256 * 1.8, 188 * 1.8)
self.enemigo.move(self.enemigo.x() - 300, self.enemigo.y() - 100)
gif_combo.start()
self.sleep(2.2)
self.enemigo.move(self.enemigo.x() + 300, self.enemigo.y() + 100)
self.enemigo.setPixmap(QPixmap(self.rutas['enemigo']))
self.enemigo.setFixedSize(91.75 * 1.1, 187.5 * 1.1)
self.barra_vida_jugador.setValue(vida)
# Vuelta
for _ in range(5):
self.enemigo.move(self.enemigo.x() + paso, self.enemigo.y())
self.sleep(0.02)
def get_path_info(self):
item = self.ui.list_widget.currentItem()
litem = item.listWidget().itemWidget(item)
_file = litem.title.text()
_path = litem.desc.text()
self.short_title(_file)
self.set_data(_path)
try:
img = tuple(self.pkg.api_icons("image"))
video = tuple(self.pkg.api_icons("video"))
audio = tuple(self.pkg.api_icons("audio"))
except TypeError:
img = ".jpg"
video = ".mp4"
audio = ".mp3"
if _file.endswith(".gif"):
self.hide_video()
movie = QMovie(_path)
movie.setScaledSize(QSize(300, 200))
self.ui.image.setMovie(movie)
movie.start()
elif _file.endswith(img):
self.hide_video()
self.ui.image.setPixmap(self.pkg.set_image(item.icon(), size=300))
elif _file.endswith(video) or _file.endswith(audio):
self.ui.image.setPixmap(self.pkg.set_image(item.icon(), size=150))
self.video_player.set_media(_path)
self.show_video()
else:
self.hide_video()
self.ui.image.setPixmap(self.pkg.set_image(item.icon(), size=150))
def handle_scan_click(self):
"""
Handle scan button action event.
Responsible for enabling waiting bar
"""
label = QLabel(self)
label.setText("SEARCHING")
self.setDisabled(True)
label_width = 500
label_height = 100
label_x_pos = self.size().width() // 2 - label_width // 2
label_y_pos = self.size().height() // 2 - label_height // 2
movie = QMovie("ajax-loader.gif")
label.setGeometry(label_x_pos, label_y_pos, label_width, label_height)
label.setFrameStyle(Qt.FramelessWindowHint)
label.setMovie(movie)
label.show()
movie.setScaledSize(label.size())
movie.start()
self.extract_data_from_fields()
def wait(self):
self.set_up()
self.socket = Server(self.__board_size, self.__is_player_first,
self.is_new, self.load_data)
self.socket.start()
self.server_timer = QBasicTimer()
self.server_timer.start(500, self)
self.__current_title = "Waiting For Second Player To Connect\n" \
f"(Your IP: {self.socket.ip})"
label = QLabel(self)
corgi = QMovie('images/BigCorgi.gif')
size = self.HEIGHT - self.UPPER_SHIFT
corgi.setScaledSize(QSize(size, size))
corgi.start()
label.setMovie(corgi)
label.move((self.WIDTH - size) / 2, (self.HEIGHT - size))
label.show()
def back_function():
label.hide()
self.first()
back = self.create_back_button(back_function)
def _set_controls(self, window_width: int, window_height: int):
''' Adds other required controls on window. '''
if self._start_button:
return
animation_label = QLabel(parent=self)
animation_movie = QMovie(app_data.animation_logo_path())
animation_movie.setScaledSize(QtCore.QSize(window_width // 1.5, window_height))
animation_label.setMovie(animation_movie)
animation_movie.start()
animation_label.resize(window_width // 1.5, window_height)
animation_label.move(0, 0)
start_button = QPushButton(QIcon(app_data.yes_logo_path()), "Start", self, default=True, autoDefault=True)
start_button.setToolTip("Start to monitor '<B>Downloads</B>' directory on system.")
start_button.resize(start_button.sizeHint())
start_button.move(window_width // 1.4, window_height // 10)
start_button.clicked.connect(self._start_clicked)
self._start_button = start_button
about_button = QPushButton(QIcon(app_data.about_logo_path()), "About", self, autoDefault=True)
about_button.setToolTip("About application & developer.")
about_button.resize(about_button.sizeHint())
about_button.move(window_width // 1.4, window_height // 3.35)
about_button.clicked.connect(self._about_clicked)
exclusions_button = QPushButton(QIcon(app_data.exclusions_logo_path()), "Exclusions", self, autoDefault=True)
exclusions_button.setToolTip("Add file/directory to be <B>ignored by app</B>.")
exclusions_button.resize(exclusions_button.sizeHint())
exclusions_button.move(window_width // 1.4, window_height // 2)
exclusions_button.clicked.connect(self._exclusions_clicked)
quit_button = QPushButton(QIcon(app_data.quit_logo_path()), "Quit", self, autoDefault=True)
quit_button.setToolTip("'<B>Quit</B>' the application.")
quit_button.resize(quit_button.sizeHint())
quit_button.move(window_width // 1.4, window_height // 1.42)
quit_button.clicked.connect(self._quit_clicked)
class LoginWidget(QWidget):
# signals
loginOk = pyqtSignal(str, dict) # (login(email), cookies{})
loginError = pyqtSignal(str)
def __init__(self, parent=None):
super(LoginWidget, self).__init__(parent)
self.uifile = 'ui/login_widget.ui'
self.pickle_filename = 'cache/login.dat'
self.xnova_url = 'uni4.xnova.su'
self.ui = None
self.loading_gif = None
# thread for network operations
self.th = None
def load_ui(self):
self.ui = uic.loadUi(self.uifile, self)
self.ui.lbl_loading.hide()
self.ui.btn_login.clicked.connect(self.on_btn_login)
self.ui.btn_register.clicked.connect(self.on_btn_register)
self.loading_gif = QMovie(':/i/loading.gif')
self.restore_login()
# load xnova url from config/net.ini
cfg = configparser.ConfigParser()
cfg.read('config/net.ini', encoding='utf-8')
if 'net' in cfg:
self.xnova_url = cfg['net']['xnova_url']
def save_login(self):
email = self.ui.le_email.text()
password = self.ui.le_pass.text()
remember = self.ui.chk_remember.isChecked()
auth_data = (email, password, remember)
try:
cache_dir = pathlib.Path('./cache')
if not cache_dir.exists():
cache_dir.mkdir()
with open(self.pickle_filename, 'wb') as f:
pickle.dump(auth_data, f)
except pickle.PickleError as pe:
pass
except IOError as ioe:
pass
# except OSError as ose: # same as IOError in python3 ?
# pass
def restore_login(self):
try:
with open(self.pickle_filename, 'rb') as f:
auth_data = pickle.load(f)
self.ui.le_email.setText(auth_data[0])
self.ui.le_pass.setText(auth_data[1])
if auth_data[2]:
self.ui.chk_remember.setChecked(True)
else:
self.ui.chk_remember.setChecked(False)
except pickle.PickleError as pe:
pass
except IOError as ioe:
pass
@pyqtSlot()
def on_btn_register(self):
logger.debug('register clicked, opening [http://{0}/]'.format(self.xnova_url))
QDesktopServices.openUrl(QUrl('http://{0}/'.format(self.xnova_url)))
@pyqtSlot()
def on_btn_login(self):
# logger.debug('login clicked')
self.ui.btn_login.hide()
self.ui.btn_register.hide()
self.ui.le_email.setEnabled(False)
self.ui.le_pass.setEnabled(False)
self.ui.chk_remember.setEnabled(False)
self.ui.lbl_loading.show()
self.ui.lbl_loading.setMovie(self.loading_gif)
self.loading_gif.start()
if self.ui.chk_remember.isChecked():
self.save_login()
# create thread object
self.th = LoginThread(self)
self.th.finished.connect(self.on_thread_finished)
# get form data and start thread
self.th.email = self.ui.le_email.text()
self.th.password = self.ui.le_pass.text()
self.th.remember = self.ui.chk_remember.isChecked()
self.th.start()
@pyqtSlot()
def on_thread_finished(self):
# logger.debug('thread finished')
self.loading_gif.stop()
self.ui.le_email.setEnabled(True)
self.ui.le_pass.setEnabled(True)
self.ui.chk_remember.setEnabled(True)
self.ui.btn_login.show()
self.ui.btn_register.show()
self.ui.lbl_loading.hide()
if self.th.login_ok:
logger.info('Login ({0}) ok'.format(self.th.email))
cookies_dict = self.th.requests_cookiejar.get_dict()
# logger.debug(cookies_dict)
# emit signal
self.loginOk.emit(self.th.email, cookies_dict)
else:
logger.error('Login error: {0}'.format(self.th.error_msg))
self.loginError.emit(self.th.error_msg)
self.th = None
