class Gold(QWidget, Ui_Form):
"""
"""
def __init__(self, parent=None):
"""
"""
super(Gold, self).__init__(parent)
self.setupUi(self)
self.value = 0
self.second = 0
self.movie = QMovie("res/farmer.gif")
self.goldNum = 0
@pyqtSlot()
def on_pushButton_clicked(self):
"""
开始挖矿
"""
self.goldNum = 0
self.second = self.spinBox.value()
self.pushButton.setEnabled(False)
self.spinBox.setEnabled(False)
self.farm(1)
self.progressBar.setMaximum(100)
self.timer = QTimer()
self.timer.start(self.second * 10)
print(self.second)
self.timer.timeout.connect(self.showProgress)
self.dig = Digging_Thread(self.second)
self.dig.gold_finish.connect(self.showResult)
self.dig.start()
def showProgress(self):
self.value += 1
self.progressBar.setValue(self.value)
if self.value == 100:
self.pushButton.setEnabled(True)
self.spinBox.setEnabled(True)
self.value = 0
self.timer.stop()
del self.timer
self.dig.quit()
del self.dig
self.farm(0)
msgBox = MsgGold(self.goldNum)
msgBox.exec()
self.progressBar.setValue(0)
self.label_farmer.setPixmap(QPixmap("res/ready.png"))
def showResult(self, r):
self.goldNum = r
def farm(self, flag):
if flag == 1:
self.label_farmer.setMovie(self.movie)
self.movie.start()
if flag == 0:
self.movie.stop()
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()
class LoadingScreen(QWidget):
def __init__(self):
super().__init__()
self.setFixedSize(150, 150)
self.setWindowFlags(Qt.FramelessWindowHint)
self.setAttribute(Qt.WA_TranslucentBackground)
self.setWindowModality(Qt.ApplicationModal)
self.move(QDesktopWidget().availableGeometry().center() -
QtCore.QPoint(75, 75))
self.label_animation = QLabel(self)
# self.label_animation.setStyleSheet("background: transparent;")
self.movie = QMovie(qtguistyle.icon_path + "/connector-loader.gif")
self.movie.setScaledSize(QtCore.QSize(150, 150))
self.label_animation.setMovie(self.movie)
# self.label_animation.setStyleSheet("background-color: rgba(0,0,0,0%)")
def keyPressEvent(self, event):
if event.key() == Qt.Key_Escape:
self.close()
def startAnimation(self):
self.movie.start()
self.show()
def stopAnimation(self):
self.movie.stop()
self.close()
def setupUi(self):
centralWidget = QtWidgets.QWidget(self)
self.setCentralWidget(centralWidget)
flags = QtCore.Qt.WindowFlags(
QtCore.Qt.FramelessWindowHint
| QtCore.Qt.WindowStaysOnTopHint if self.on_top else QtCore.Qt.
FramelessWindowHint)
self.setWindowFlags(flags)
self.setAttribute(QtCore.Qt.WA_NoSystemBackground, True)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground, True)
label = QtWidgets.QLabel(centralWidget)
movie = QMovie(self.img_path)
label.setMovie(movie)
movie.start()
movie.stop()
w = int(movie.frameRect().size().width() * self.size)
h = int(movie.frameRect().size().height() * self.size)
movie.setScaledSize(QtCore.QSize(w, h))
movie.start()
self.setGeometry(self.xy[0], self.xy[1], w, h)
self.del_label = QtWidgets.QLabel(centralWidget)
self.del_movie = QMovie('gif/Boom3.gif')
self.del_label.setMovie(self.del_movie)
self.del_movie.setScaledSize(QtCore.QSize(w, h))
self.del_movie.start()
self.del_label.hide()
self.setGeometry(self.xy[0], self.xy[1], w, h)
def setupUi(self):
"""
위젯을 화면 위에 올리기
:return:
"""
# contralWidget 정의 :: 정의 안하면 안보임
centralWidget = QtWidgets.QWidget(self)
self.setCentralWidget(centralWidget)
# FramelessWindowHint :: 창의 윗부분이 사라짐(닫기, 최소화 등등 있는 것)
# WindowStaysOnTopHint :: 화면 항상 위에 있어라. 아래 if문을 만족하면
flags = QtCore.Qt.WindowFlags(
QtCore.Qt.FramelessWindowHint
| QtCore.Qt.WindowStaysOnTopHint if self.on_top else QtCore.Qt.
FramelessWindowHint)
# Wa_ :: 창 배경을 깨끗하고 맑고 투명하게
self.setWindowFlags(flags)
self.setAttribute(QtCore.Qt.WA_NoSystemBackground, True)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground, True)
label = QtWidgets.QLabel(centralWidget) # 만든 contralWidget을 label에 올리기
movie = QMovie(self.img_path) # 위치확인
label.setMovie(movie) # 라벨셋팅
movie.start()
movie.stop() # 크기를 구하기위해 한번 켰다끄기
#사이즈 정의
w = int(movie.frameRect().size().width() * self.size)
h = int(movie.frameRect().size().height() * self.size)
movie.setScaledSize(QtCore.QSize(w, h))
movie.start()
# 크기 위치 정의
self.setGeometry(self.xy[0], self.xy[1], w, h)
class FunDialogPlayer(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
# setGeometry(x_pos, y_pos, width, height)
self.setGeometry(200, 200, 400, 400)
self.setWindowTitle("QMovie to show animated gif")
# set up the movie screen on a label
self.movie_screen = QLabel()
# expand and center the label
self.movie_screen.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.movie_screen.setAlignment(Qt.AlignCenter)
main_layout = QVBoxLayout()
main_layout.addWidget(self.movie_screen)
self.setLayout(main_layout)
# use an animated gif file you have in the working folder
# or give the full file path
self.movie = QMovie("giphy.gif", QByteArray(), self)
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
self.movie_screen.setMovie(self.movie)
self.movie.start()
def start(self):
"""sart animnation"""
self.show()
self.movie.start()
def stop(self):
"""stop the animation"""
self.movie.stop()
self.hide()
class UI_LoginBar(QWidget):
def __init__(self, parent=None):
super(UI_LoginBar, self).__init__(parent)
self.setupUi()
self.pushButton.clicked.connect(self.run)
self.pushButton2.clicked.connect(self.run)
def setupUi(self):
self.setObjectName("MainWindow")
self.resize(500, 300) # 设置大小
self.setWindowTitle("XX登录界面") # 设置标题
self.setFixedSize(self.width(), self.height()) # 禁止最大化
icon = QIcon()
icon.addPixmap(QPixmap("..\\Image\\10.jpg"), QtGui.QIcon.Normal,
QtGui.QIcon.Off)
self.setWindowIcon(icon) # 设置窗口的图标
self.pushButton = QPushButton(self)
self.pushButton.setGeometry(135, 230, 230, 30)
self.pushButton2 = QPushButton(self)
self.pushButton2.setGeometry(135, 265, 230, 30)
self.pushButton.setObjectName("pushButton")
self.pushButton.setText("登录")
self.lable = QLabel(self)
self.lable.setGeometry(75, 100, 350, 50)
self.movie = QMovie("1.gif")
def run(self):
self.lable.setMovie(self.movie)
if self.sender() == self.pushButton:
self.movie.start()
else:
self.movie.stop()
self.lable.setPixmap(QPixmap(""))
class LoadingGifWidget(object):
def mainUI(self, FrontWindow):
FrontWindow.setObjectName("FTwindow")
FrontWindow.resize(320, 300)
self.centralwidget = QtWidgets.QWidget(FrontWindow)
self.centralwidget.setObjectName("main-widget")
# Label Create
self.label = QtWidgets.QLabel(self.centralwidget)
self.label.setGeometry(QtCore.QRect(25, 25, 200, 200))
self.label.setMinimumSize(QtCore.QSize(250, 250))
self.label.setMaximumSize(QtCore.QSize(250, 250))
self.label.setObjectName("lb1")
FrontWindow.setCentralWidget(self.centralwidget)
# Loading the GIF
self.movie = QMovie("spinner.gif")
self.label.setMovie(self.movie)
self.startAnimation()
# Start Animation
def startAnimation(self):
self.movie.start()
# Stop Animation(According to need)
def stopAnimation(self):
self.movie.stop()
class LoadingGif(QWidget):
def __init__(self):
super().__init__()
self.setFixedSize(80, 80)
self.setWindowFlags(Qt.WindowStaysOnTopHint | Qt.CustomizeWindowHint)
self.label_animation = QLabel(self)
self.movie = QMovie('spinner.gif')
self.label_animation.setMovie(self.movie)
timer = QTimer(self)
self.startAnimation()
# timer.singleShot(3000, self.stopAnimation)
# self.show()
def startAnimation(self):
self.movie.start()
def stopAnimation(self):
self.movie.stop()
self.close()
def pop_up(self, message):
msg = QMessageBox()
msg.setWindowTitle("Message")
msg.setText(str(message))
msg.setIcon(QMessageBox.Information)
msg.setStandardButtons(QMessageBox.Ok)
msg.buttonClicked.connect(self.button_click)
x = msg.exec_()
def button_click(self, i):
print(i.text())
print("DONE")
self.close()
def updateSignal(self):
vCloud = 'https://digital-ies.de/wp-content/uploads'
movie = QMovie(
os.path.dirname(sys.argv[0]) + "/pics/loader.gif", QByteArray(),
self)
movie.setCacheMode(QMovie.CacheAll)
movie.setSpeed(100)
self.y.label_44.setMovie(movie)
x = threading.Thread(target=movie.start())
x.setDaemon(True)
x.start()
http = urllib3.PoolManager()
response = http.request(
'GET',
"https://digital-ies.de/wp-content/uploads/myActualVersion.txt")
data = response.data.decode('utf-8')
if str(data) != str(version):
y = threading.Thread(target=self.meinDownload, args=(vCloud, ))
y.setDaemon(True)
y.start()
while not os.path.exists(
os.path.dirname(sys.argv[0]) + "/setup.exe"):
QApplication.instance().processEvents()
time.sleep(5)
movie.stop()
self.y.label_44.setMovie(None)
self.y.pushButton_19.setVisible(True)
p2 = subprocess.Popen(
os.path.dirname(sys.argv[0]) + "/unins000.exe")
p2.wait()
subprocess.Popen(os.path.dirname(sys.argv[0]) + "/setup.exe")
os.system("taskkill /f /im LIMASCalc.exe")
class LoadingScreen(QWidget):
def __init__(self):
super().__init__()
self.setFixedSize(200, 200)
self.setWindowFlags(
Qt.SplashScreen
)
self.setAttribute(Qt.WA_TranslucentBackground)
self.setWindowModality(Qt.ApplicationModal)
self.label_animation = QLabel(self)
self.label_animation.setStyleSheet("background: transparent;")
self.movie = QMovie('images/fluid-loader.gif')
self.movie.setScaledSize(QtCore.QSize(200, 200))
self.label_animation.setMovie(self.movie)
self.label_animation.setStyleSheet("background-color: rgba(0,0,0,0%)")
def keyPressEvent(self, event):
if event.key() == Qt.Key_Escape:
self.close()
def startAnimation(self):
self.movie.start()
self.show()
def stopAnimotion(self):
self.movie.stop()
self.close()
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()
class MainWidget(QWidget):
def __init__(self, parent=None):
super(MainWidget, self).__init__(parent)
self.setAttribute(Qt.WA_StyledBackground, True)
self.setStyleSheet('background-color: white')
self.label = QLabel()
# 居中对齐
self.label.setAlignment(Qt.AlignCenter | Qt.AlignVCenter)
self.loading = QMovie("images/loading.gif")
self.label.setMovie(self.loading)
self.layout = QHBoxLayout()
self.layout.addWidget(self.label)
self.loading_start()
self.setLayout(self.layout)
# 定时器
self.t = QTimer()
self.t.start(8000)
self.t.timeout.connect(self.loading_end)
def loading_end(self):
self.t.stop()
self.loading.stop()
time.sleep(0.2)
self.label.clear()
def loading_start(self):
self.loading.start()
class MainWindow(QMainWindow):
my_signal = pyqtSignal()
def __init__(self, *args, **kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
global file, pagecount, total, enabler, option
file = ""
pagecount = 0
total = 0.0
option = ""
self.setWindowTitle("Printing Booth Systems")
self.movie = QMovie("menu.gif")
self.movie.frameChanged.connect(self.repaint)
self.movie.start()
self.btn = QPushButton('Touch here to Begin', self)
self.btn.setGeometry(200, 230, 400, 100)
self.btn.setFont(QFont('Arial', 30))
self.btn.clicked.connect(self.slot_btn_function)
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)
def slot_btn_function(self):
self.fs = FileSelect()
self.fs.showFullScreen()
self.movie.stop()
self.hide()
class Test(QWidget):
def __init__(self):
super(Test, self).__init__()
self.label = QLabel('', self)
self.label.move(0, 300)
self.setFont(QFont('Arial'))
self.setFixedSize(1500, 600)
self.setWindowFlags(Qt.Dialog | Qt.CustomizeWindowHint)
self.movie = QMovie("Images/1.gif")
self.movie.setScaledSize(QSize(1500, 100))
self.label.setMovie(self.movie)
self.movie.start()
self._label = QLabel('请向前行驶', self)
self._label.move(650, 345)
self._label.setStyleSheet('color: rgb(255, 255, 255)')
font = self._label.font()
font.setPixelSize(55)
self._label.setFont(font)
self._label.show()
self.btn = QPushButton(self)
self.btn.move(100, 100)
self.btn.setText('TEST')
self.btn.clicked.connect(self.change_gif)
def change_gif(self):
self.movie.stop()
self._label.setText('')
self._label.setStyleSheet('color: rgb(255, 255, 255)')
self.movie = QMovie('Images/1.gif')
self.movie.setScaledSize(QSize(1500, 100))
self.label.setMovie(self.movie)
self.movie.start()
class Indicator_dialog(QDialog):
def __init__(self, parent, title, mypath, inst_list):
super().__init__(parent)
# constants
self.title = title
self.mypath = mypath
self.inst_list = inst_list
self.closenow = False
self.setupUi()
def setupUi(self):
dummy = QLabel("", self)
dummy.setFixedWidth(100)
lbl_movie = QLabel("", self)
self.movie = QMovie(self.mypath, QByteArray(), self)
lbl_movie.setMovie(self.movie)
grid_0 = QHBoxLayout()
grid_0.addWidget(dummy)
grid_0.addWidget(lbl_movie)
grid_0.addWidget(dummy)
self.stopButton = QPushButton("STOP RESET", self)
self.stopButton.setEnabled(False)
grid_1 = QVBoxLayout()
grid_1.addLayout(grid_0)
grid_1.addWidget(self.stopButton)
# cancel the script run
self.stopButton.clicked.connect(self.abort)
self.setLayout(grid_1)
self.setWindowTitle(self.title)
self.movie.start()
self.setModal(True)
self.show()
def abort(self):
if self.inst_list.get("SMC100"):
self.inst_list.get("SMC100").move_stop(1)
def close_(self):
self.movie.stop()
self.closenow = True
self.close()
def closeEvent(self, event):
if self.closenow:
event.accept()
else:
event.ignore()
def run(self):
movie = QMovie("icon/movie.gif")
self.lb.setMovie(movie)
if self.sender() == self.bt1:
movie.start()
else:
movie.stop()
self.lb.setPixmap(self.pix)
class LoadingWidget(QWidget, QObject):
complete = pyqtSignal()
def __init__(self, parent):
QWidget.__init__(self, parent)
QObject.__init__(self)
self.setStyleSheet("background-color: #31353a;")
self.setAutoFillBackground(True)
self.gifPath = "img/loading.gif"
self.initUI()
def initUI(self):
layout = QBoxLayout(QBoxLayout.TopToBottom, self)
self.setLayout(layout)
self.loadingMovie = QMovie(self.gifPath)
self.loadingImg = QLabel(self)
self.loadingImg.setMovie(self.loadingMovie)
self.loadingImg.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.loadingImg.setAlignment(Qt.AlignCenter)
self.logLabel = QLabelLogger(self)
self.logLabel.setFormatter(logging.Formatter('%(message)s'))
logging.getLogger().addHandler(self.logLabel)
logging.getLogger().setLevel(logging.INFO)
self.loadingBar = QProgressBar(self)
self.loadingBar.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
self.loadingBar.setFixedHeight(10)
self.loadingBar.setTextVisible(False)
self.barThread = LoadingBarThread(self)
self.barThread.change_value.connect(self.loadingBar.setValue)
self.barThread.complete.connect(self.clear)
layout.addWidget(self.loadingImg)
layout.addWidget(self.logLabel.widget)
layout.addWidget(self.loadingBar)
self.layout().setContentsMargins(0, 0, 0, 0)
def start(self):
self.loadingMovie.start()
self.barThread.start()
self.show()
def resume(self):
if self.barThread.cnt <= 50:
self.barThread.cnt = 100
return
self.barThread.toggle_status()
if self.loadingMovie.state() != QMovie.Running:
self.loadingMovie.start()
def clear(self):
self.loadingMovie.stop()
self.complete.emit()
def __setup_code_generation_progress_loader(self):
widget_movie = QMovie("assets/loader.gif")
widget_movie.setScaledSize(QSize(64, 64))
self.widget_progress = widget_movie
self.label.setMovie(widget_movie)
self.label.show()
widget_movie.start()
widget_movie.stop()
class IntroOverlay(_OverlayWidget):
opaque_timer = QtCore.QTimer()
opaque_timer.setSingleShot(True)
finished_signal = QtCore.pyqtSignal()
def __init__(self, parent):
super(IntroOverlay, self).__init__(parent)
self.parent = parent
self.intro_mov = QMovie(':/anim/Introduction.gif')
self.intro_mov.setCacheMode(QMovie.CacheAll)
self.intro_mov.finished.connect(self.finished)
self.opaque_timer.timeout.connect(self.set_opaque_for_mouse_events)
self.installEventFilter(self)
def eventFilter(self, obj, event):
if obj is None or event is None:
return False
if obj is self:
if event.type() == QtCore.QEvent.MouseButtonPress:
self.mouse_click()
return True
return False
def set_opaque_for_mouse_events(self):
self.setAttribute(QtCore.Qt.WA_TransparentForMouseEvents, False)
def intro(self):
LOGGER.info('Playing introduction in %sx %sy %spx %spx',
self.parent.rect().x(), self.parent.rect().y(),
self.parent.rect().width(), self.parent.rect().height())
self.movie_screen.setMovie(self.intro_mov)
self.movie_screen.setGeometry(self.parent.rect())
self._updateParent()
self.opaque_timer.start(1000)
self.movie_screen.show()
self.show()
self.intro_mov.jumpToFrame(0)
self.intro_mov.start()
def mouse_click(self):
self.intro_mov.stop()
self.finished()
def finished(self):
self.movie_screen.hide()
self.hide()
self.finished_signal.emit()
class Indicator_dialog(QDialog):
def __init__(self, parent, title, mypath):
super().__init__(parent)
# constants
self.title = title
self.mypath = mypath
self.closenow=False
self.setupUi()
def setupUi(self):
dummy = QLabel("",self)
dummy.setFixedWidth(60)
text = QLabel("Enter the Gmail password\nin the terminal prompt",self)
lbl_movie = QLabel("",self)
self.movie = QMovie(self.mypath, QByteArray(),self)
lbl_movie.setMovie(self.movie)
grid_0 = QHBoxLayout()
grid_0.addWidget(dummy)
grid_0.addWidget(lbl_movie)
grid_0.addWidget(dummy)
grid_1 = QVBoxLayout()
grid_1.addWidget(text)
grid_1.addLayout(grid_0)
self.setLayout(grid_1)
self.setWindowTitle(self.title)
self.movie.start()
self.setModal(True)
self.show()
def close_(self):
self.movie.stop()
self.closenow=True
self.close()
def closeEvent(self,event):
if self.closenow:
event.accept()
else:
event.ignore()
class GifSplashScreen(QSplashScreen):
def __init__(self, *args, **kwargs):
super(GifSplashScreen, self).__init__(*args, **kwargs)
self.movie = QMovie('image/splash.gif')
self.movie.frameChanged.connect(self.onFrameChanged)
self.movie.start()
def onFrameChanged(self, _):
self.setPixmap(self.movie.currentPixmap())
def finish(self, widget):
self.movie.stop()
super(GifSplashScreen, self).finish(widget)
class QBusyWidget(QLabel,
QObserver,
qobservables={BusyObservable: {'busy_changed'}}):
"""A widget indicating a that some component is busy.
"""
_label: QLabel = None
_movie: QMovie = None
_busy: bool = None
def __init__(self, **kwargs):
super().__init__(**kwargs)
# Animated gifs can be obtained from
# http://www.ajaxload.info/#preview
self._busy = None
self._movie = QMovie(os.path.join('assets', 'busy.gif'))
self.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
def busy_changed(self, busyBody: BusyObservable,
change: BusyObservable.Change) -> None:
"""React to a change of business.
"""
LOG.debug("QBusyWidget[%s].busy_changed(%s): %s", busyBody, change,
busyBody.busy)
self.setBusy(busyBody.busy)
def busy(self) -> bool:
return self._busy
def setBusy(self, busy: bool) -> None:
if busy is not self._busy:
self._busy = busy
self.update()
def update(self) -> None:
self._movie.setPaused(not self._busy)
if self._busy:
# Setting the text clears any previous content (like
# text, picture, etc.)
self.setMovie(self._movie)
else:
# Setting the text clears any previous content (like
# picture, movie, etc.)
self.setText("Not busy")
super().update()
def __del__(self):
"""Free resources used by this :py:class:`QBusyWidget`.
"""
# Make sure the movie stops playing.
self._movie.stop()
del self._movie
class ShowMovie(QLabel):
def __init__(self,width,height,parent):
super(ShowMovie,self).__init__()
self.setParent(parent)
self.setGeometry(width/2 - 100, height / 2 - 100, 200, 200)
self.movie = QMovie("./pic/loading.gif")
self.movie.setScaledSize(self.size())
self.setMovie(self.movie)
def showMovie(self):
self.show()
self.movie.start()
def cloMovie(self):
self.movie.stop()
self.close()
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 Indicator_invs_dialog(QDialog):
def __init__(self, parent, title, textcolor, mypath):
super().__init__(parent)
# constants
self.title = title
self.mypath = mypath
self.textcolor = textcolor
self.closenow = False
self.setupUi()
def setupUi(self):
title = QLabel(self.title, self)
title.setStyleSheet(''.join(
["QWidget {font: 14pt; color: ", self.textcolor, "}"]))
lbl_movie = QLabel("", self)
self.movie = QMovie(self.mypath, QByteArray(), self)
lbl_movie.setMovie(self.movie)
lbl_movie.setAlignment(Qt.AlignCenter)
grid_0 = QVBoxLayout()
grid_0.addWidget(title)
grid_0.addWidget(lbl_movie)
self.setLayout(grid_0)
self.setWindowFlags(self.windowFlags() | Qt.FramelessWindowHint)
self.setAttribute(Qt.WA_TranslucentBackground)
self.movie.start()
self.setModal(True)
self.show()
def close_(self):
self.movie.stop()
self.closenow = True
self.close()
def closeEvent(self, event):
if self.closenow:
event.accept()
else:
event.ignore()
class LoadingScreen(QWidget):
def __init__(self):
super().__init__()
self.setFixedSize(200, 200)
self.setWindowFlags(Qt.WindowStaysOnTopHint | Qt.CustomizeWindowHint)
self.label_animation = QLabel(self)
self.movie = QMovie(Index.LoadingGif)
self.label_animation.setMovie(self.movie)
def startAnimation(self):
print("start animation")
self.movie.start()
self.show()
def stopAnimation(self):
self.movie.stop()
self.close()
class Throbber(QLabel):
"""A throbber."""
def __init__(self):
super(Throbber, self).__init__()
self.setAlignment(Qt.AlignCenter)
fname = multiplatform.get_path("encuentro/ui/media/throbber.gif")
self._movie = QMovie(fname)
self.setMovie(self._movie)
def hide(self):
"""Overload to control the movie."""
self._movie.stop()
super(Throbber, self).hide()
def show(self):
"""Overload to control the movie."""
self._movie.start()
super(Throbber, self).show()
class Loadingg(QWidget):
def __init__(self):
super().__init__()
self.setFixedSize(200, 200)
self.setWindowFlag(Qt.WindowStaysOnTopHint | Qt.CustomizeWindowHint)
self.movie = QMovie('111.gif')
self.label_anim = QLabel(self)
self.label_anim.setMovie(self.movie)
self.start_anim()
self.show()
def start_anim(self):
self.movie.start()
def stop_anim(self):
self.movie.stop()
self.close()
class Loading(QWidget, QMovie):
def __init__(self, parent=None):
super().__init__()
# setGeometry(x_pos, y_pos, width, height)
self.setGeometry(200, 200, 400, 400)
self.setWindowTitle("QMovie to show animated gif")
# set up the movie screen on a label
self.movie_screen = QLabel()
# expand and center the label
self.movie_screen.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.movie_screen.setAlignment(Qt.AlignCenter)
btn_start = QPushButton("Start Animation")
btn_start.clicked.connect(self.start)
btn_stop = QPushButton("Stop Animation")
btn_stop.clicked.connect(self.stop)
main_layout = QVBoxLayout()
main_layout.addWidget(self.movie_screen)
main_layout.addWidget(btn_start)
main_layout.addWidget(btn_stop)
self.setLayout(main_layout)
# use an animated gif file you have in the working folder
# or give the full file path
self.movie = QMovie("loading.gif", QByteArray(), self)
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
self.movie_screen.setMovie(self.movie)
timer = QTimer(self)
self.startAnimation()
timer.singleShot(3000, self.stopAnimation)
self.show()
def start(self):
"""sart animnation"""
self.movie.start()
def stop(self):
"""stop the animation"""
self.movie.stop()
class MoviePlayer(QMainWindow):
def __init__(self, *args):
QMainWindow.__init__(self, *args)
# setGeometry(x_pos, y_pos, width, height)
self.setGeometry(200, 200, 400, 400)
self.setWindowTitle("QMovie to show animated gif")
# set up the movie screen on a label
self.movie_screen = QLabel()
# expand and center the label
self.movie_screen.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
#btn_start = QPushButton("Start Animation", self)
# btn_start.clicked.connect(self.start)
btn_stop = QPushButton("Stop Animation", self)
btn_stop.clicked.connect(self.stop)
main_layout = QVBoxLayout()
main_layout.addWidget(self.movie_screen)
# main_layout.addWidget(btn_start)
main_layout.addWidget(btn_stop)
self.setLayout(main_layout)
# use an animated gif file you have in the working folder
# or give the full file path
self.movie = QMovie("./AG_Dog.gif", QByteArray(), self)
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
self.movie_screen.setMovie(self.movie)
self.movie.start()
def start(self):
"""sart animnation"""
self.movie.start()
def stop(self):
"""stop the animation"""
self.movie.stop()
print(self.movie.fileName())
self.movie.start()
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 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
class MainWindow(QMainWindow):
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
#self.player_window = player_w
@Slot(str, bool)
def openVideo(self, filepath, duplicate_mode):
movie = os.path.expanduser(filepath)
if 'http://' not in filepath:
if not os.access(movie, os.R_OK):
print(('Error: %s file is not readable' % movie))
sys.exit(1)
split = urllib.parse.urlsplit(filepath)
#name = QInputDialog.getText(self, 'Escolha nome do arquivo', 'Nome do arquivo:')
name = split.path.split("/")[-1]
#pa = os.path.join(res, name)
if duplicate_mode:
try:
#media = instance.media_new(movie, 'sout=#duplicate{dst=file{dst=%s},dst=display}' % pa)
pass
except NameError:
print(('NameError: % (%s vs Libvlc %s)' % (sys.exc_info()[1],
vlc.__version__, vlc.libvlc_get_version())))
else:
try:
#media = instance.media_new(movie)
if sys.platform in 'win32':
subprocess.Popen([os.path.join('vlc','vlc'), movie])
else:
subprocess.Popen(['vlc', movie])
except NameError:
print(('NameError: % (%s vs Libvlc %s)' % (sys.exc_info()[1],
vlc.__version__, vlc.libvlc_get_version())))
QMessageBox.critical(self, 'Erro','problema ao iniciar o vlc')
# "--sout=#duplicate{dst=file{dst=example.mpg},dst=display}"
#player = instance.media_player_new()
#pplayer.set_media(media)
#self.player_window.setMedia(media)
#self.player_window.createUI()
#self.player_window = Player()
#media.parse()
#self.player_window.setWindowTitle(media.get_meta(0))
#self.player_window.show()
#self.player_window.resize(640, 480)
#if sys.platform == "linux2": # for Linux using the X Server
# pplayer.set_xwindow(self.player_window.videoframe.winId())
#elif sys.platform == "win32": # for Windows
# pplayer.set_hwnd(self.player_window.videoframe.winId())
#elif sys.platform == "darwin": # for MacOS
# pplayer.set_agl(self.player_window.videoframe.windId())
#pplayer.play()
#self.player_window.updateUI()
@Slot(str, str)
def start_download(self, filepath, path):
#thread = QThread(self)
pbar = QProgressBar(self.ui.tab_downloads)
pbar.setMinimum(0)
pbar.setMaximum(100)
pbar.setValue(0)
self.ui.formLayout.addRow(os.path.basename(path), pbar)
pbar.show()
dw = Downloader(str(filepath), str(path), pbar)
dw.finished.connect(self.finished_download)
dw.progresschanged.connect(self.show_download_progress)
dw.started.connect(self.started_download)
Thread(target=dw.download).start()
#thread.started.connect(dw.download)
#thread.finished.connect(self.finished_download)
#dw.moveToThread(thread)
#thread.start()
def finished_download(self, pbar, filename):
self.tray.showMessage(filename, 'Download concluído.')
pbar.setValue(100)
pbar.setEnabled(False)
def started_download(self, filename):
filename = os.path.basename(filename)
self.tray.showMessage(filename, 'Download iniciado.')
@Slot(float, QProgressBar)
def show_download_progress(self, progress, pbar):
pbar.setValue(progress)
def show_feedback(self):
feed = Feedback(self.com)
feed.exec_()
def about_semard(self):
about = QMessageBox.about(self, "Sobre Semard",
"""<b>Semard</b> v%s
<p><b>Copyright (C) 2013</b> Ronnie Andrew.</p>
<p>Todos os direitos reservados de acordo com a licença GNU GPL v3 ou posterior.</p>
<p><b>Website Oficial:</b> <a href='https://github.com/ROAND/Series-Manager'>GitHub</a></p>
<p><b>Plataforma: </b>%s</p>
""" % (__version__, platform.system()))
def show_semard(self, message):
self.show()
def closeEvent(self, event):
self.hide()
self.tray.showMessage('Semard', 'Semard ainda está em execução.')
event.ignore()
@Slot(str)
def set_image(self, img_str):
self.ui.image_label.setPixmap(QPixmap(img_str))
@Slot(str)
def message(self, message):
if str(message) in 'ended':
self.ui.loading_label.hide()
# self.repaint()
self.ui.anime_list_widget.setEnabled(True)
self.ui.show_button.setEnabled(True)
self.movie.stop()
if str(message) in 'started':
self.ui.loading_label.show()
# self.repaint()
self.ui.anime_list_widget.setEnabled(False)
self.ui.show_button.setEnabled(False)
self.movie.start()
def anime_entered(self, item):
pass
def load_url_items(self):
self.com.sig.emit('started')
self.main_download_page = AnimeList('http://www.anbient.net/lista')
self.number, self.anime_list = self.main_download_page.get_attrs()
self.ui.avaLabel.setText('%s disponiveis.' % self.number)
self.add_full_items_animelist()
self.com.sig.emit('ended')
def episode_change(self):
self.com.sig.emit('started')
self.ui.options_list_widget.clear()
if self.ui.res_list_widget.currentItem():
name = self.ui.res_list_widget.currentItem().text()
episode = self.episode_list[name]
self.ui.options_list_widget.addItems(episode.links)
self.com.sig.emit('ended')
def download(self):
#name = self.ui.options_list_widget.currentItem().text()
link = self.ui.options_list_widget.currentItem().text()
self.com.sig.emit('started')
msgBox = QMessageBox()
msgBox.setWindowTitle('Informação')
msgBox.setText('Browser padrão')
msgBox.setInformativeText(
'Você deseja abrir este link com o seu browser padrão?')
msgBox.setStandardButtons(QMessageBox.No | QMessageBox.Yes)
msgBox.setDefaultButton(QMessageBox.Yes)
ret = msgBox.exec_()
if ret == QMessageBox.Yes:
if sys.platform in 'win32':
webbrowser.open(link)
else:
webbrowser.open(link)
else:
browser.ui.webView.setUrl(QUrl(link))
browser.show()
self.com.sig.emit('ended')
def keyPressEvent(self, event):
if isinstance(event, PyQt5.QtGui.QKeyEvent):
if event.key() == Qt.Key_Down:
self.ui.anime_list_widget.setCurrentRow(
self.ui.anime_list_widget.currentRow() + 1)
elif event.key() == Qt.Key_Up:
self.ui.anime_list_widget.setCurrentRow(
self.ui.anime_list_widget.currentRow() - 1)
@staticmethod
def get_img_link(url):
page = urllib.request.urlopen(url)
page_string = page.read().decode('utf-8')
soup = BeautifulSoup(page_string)
spans = soup.find_all('span', {'id': 'posterspan'})
link = None
for chil in spans:
if isinstance(chil, bs4.element.Tag):
for img in chil.children:
if isinstance(img, bs4.element.Tag):
link = img['src']
return link
def show_ep_thread(self):
self.ui.res_list_widget.clear()
anime_name = self.ui.anime_list_widget.currentItem().text()
link = self.anime_list[anime_name]
self.episodes = EpisodeList(link)
# self.episodes.join()
self.link = self.get_img_link(link)
self.episode_list = self.episodes.get_episodes()
anime_name = self.ui.anime_list_widget.currentItem().text()
link = self.anime_list[anime_name]
img_link = self.get_img_link(link)
file_name = img_link
if os.path.exists(get_file(file_name)):
self.com.img.emit(get_file(file_name))
# self.ui.image_label.setPixmap(QPixmap(get_file(file_name)))
else:
if img_link is not None:
file_name = img_link.replace(
'http://www.anbient.net/sites/default/files/imagecache/242x0/imagens/poster/', '')
urllib.request.urlretrieve(
'http://www.anbient.net/sites/default/files/imagecache/242x0/imagens/poster/%s' % file_name,
get_file(file_name))
self.com.img.emit(get_file(file_name))
# self.ui.image_label.setPixmap(QPixmap(get_file(file_name)))
self.ui.label_sinopse.setText(self.episodes.get_sinopse().strip())
try:
for name in reversed(sorted(list(self.episode_list.keys()), key=int)):
episode = self.episode_list[name]
name, links = episode.get_attrs()
self.ui.res_list_widget.addItem(name)
except:
for name, episode in reversed(sorted(self.episode_list.items())):
name, links = episode.get_attrs()
self.ui.res_list_widget.addItem(name)
self.com.sig.emit('ended')
def show_episodes(self):
Thread(target=self.show_ep_thread).start()
self.com.sig.emit('started')
def add_full_items_animelist(self):
self.ui.anime_list_widget.clear()
for name, link in sorted(self.anime_list.items()):
self.ui.anime_list_widget.addItem(name)
def search_text_changed(self, new_text):
items = self.ui.anime_list_widget.findItems(new_text, Qt.MatchContains)
if items:
self.ui.anime_list_widget.setCurrentItem(items[0])
self.ui.labelSearch.setText('')
else:
self.ui.labelSearch.setText('Not Found!')
def setBrowser(self, browser_param):
self.browser = browser_param
self.browser.start_download.connect(self.start_download)
self.browser.open_video.connect(self.openVideo)
class SystemTrayIcon(QMainWindow):
def __init__(self, parent=None):
super(SystemTrayIcon, self).__init__(parent)
self.setAttribute(Qt.WA_DeleteOnClose)
self.settings = QSettings()
self.language = self.settings.value('Language') or ''
self.temp_decimal_bool = self.settings.value('Decimal') or False
# initialize the tray icon type in case of first run: issue#42
self.tray_type = self.settings.value('TrayType') or 'icon&temp'
cond = conditions.WeatherConditions()
self.temporary_city_status = False
self.conditions = cond.trans
self.clouds = cond.clouds
self.wind = cond.wind
self.wind_dir = cond.wind_direction
self.wind_codes = cond.wind_codes
self.inerror = False
self.tentatives = 0
self.baseurl = 'http://api.openweathermap.org/data/2.5/weather?id='
self.accurate_url = 'http://api.openweathermap.org/data/2.5/find?q='
self.forecast_url = ('http://api.openweathermap.org/data/2.5/forecast/'
'daily?id=')
self.day_forecast_url = ('http://api.openweathermap.org/data/2.5/'
'forecast?id=')
self.wIconUrl = 'http://openweathermap.org/img/w/'
apikey = self.settings.value('APPID') or ''
self.appid = '&APPID=' + apikey
self.forecast_icon_url = self.wIconUrl
self.timer = QTimer(self)
self.timer.timeout.connect(self.refresh)
self.menu = QMenu()
self.citiesMenu = QMenu(self.tr('Cities'))
self.tempCityAction = QAction(self.tr('&Temporary city'), self)
self.refreshAction = QAction(self.tr('&Update'), self)
self.settingsAction = QAction(self.tr('&Settings'), self)
self.aboutAction = QAction(self.tr('&About'), self)
self.exitAction = QAction(self.tr('Exit'), self)
self.exitAction.setIcon(QIcon(':/exit'))
self.aboutAction.setIcon(QIcon(':/info'))
self.refreshAction.setIcon(QIcon(':/refresh'))
self.settingsAction.setIcon(QIcon(':/configure'))
self.tempCityAction.setIcon(QIcon(':/tempcity'))
self.citiesMenu.setIcon(QIcon(':/bookmarks'))
self.menu.addAction(self.settingsAction)
self.menu.addAction(self.refreshAction)
self.menu.addMenu(self.citiesMenu)
self.menu.addAction(self.tempCityAction)
self.menu.addAction(self.aboutAction)
self.menu.addAction(self.exitAction)
self.settingsAction.triggered.connect(self.config)
self.exitAction.triggered.connect(qApp.quit)
self.refreshAction.triggered.connect(self.manual_refresh)
self.aboutAction.triggered.connect(self.about)
self.tempCityAction.triggered.connect(self.tempcity)
self.systray = QSystemTrayIcon()
self.systray.setContextMenu(self.menu)
self.systray.activated.connect(self.activate)
self.systray.setIcon(QIcon(':/noicon'))
self.systray.setToolTip(self.tr('Searching weather data...'))
self.notification = ''
self.notification_temp = 0
self.notifications_id = ''
self.systray.show()
# The dictionnary has to be intialized here. If there is an error
# the program couldn't become functionnal if the dictionnary is
# reinitialized in the weatherdata method
self.weatherDataDico = {}
# The traycolor has to be initialized here for the case when we cannot
# reach the tray method (case: set the color at first time usage)
self.traycolor = ''
self.refresh()
def icon_loading(self):
self.gif_loading = QMovie(":/loading")
self.gif_loading.frameChanged.connect(self.update_gif)
self.gif_loading.start()
def update_gif(self):
gif_frame = self.gif_loading.currentPixmap()
self.systray.setIcon(QIcon(gif_frame))
def manual_refresh(self):
self.tentatives = 0
self.refresh()
def cities_menu(self):
# Don't add the temporary city in the list
if self.temporary_city_status:
return
self.citiesMenu.clear()
cities = self.settings.value('CityList') or []
if type(cities) is str:
cities = eval(cities)
try:
current_city = (self.settings.value('City') + '_' +
self.settings.value('Country') + '_' +
self.settings.value('ID'))
except:
# firsttime run,if clic cancel in setings without any city configured
pass
# Prevent duplicate entries
try:
city_toadd = cities.pop(cities.index(current_city))
except:
city_toadd = current_city
finally:
cities.insert(0, city_toadd)
# If we delete all cities it results to a '__'
if (cities is not None and cities != '' and cities != '[]' and
cities != ['__']):
if type(cities) is not list:
# FIXME sometimes the list of cities is read as a string (?)
# eval to a list
cities = eval(cities)
# Create the cities list menu
for city in cities:
action = QAction(city, self)
action.triggered.connect(partial(self.changecity, city))
self.citiesMenu.addAction(action)
else:
self.empty_cities_list()
@pyqtSlot(str)
def changecity(self, city):
cities_list = self.settings.value('CityList')
logging.debug('Cities' + str(cities_list))
if cities_list is None:
self.empty_cities_list()
if type(cities_list) is not list:
# FIXME some times is read as string (?)
cities_list = eval(cities_list)
prev_city = (self.settings.value('City') + '_' +
self.settings.value('Country') + '_' +
self.settings.value('ID'))
citytoset = ''
# Set the chosen city as the default
for town in cities_list:
if town == city:
ind = cities_list.index(town)
citytoset = cities_list[ind]
citytosetlist = citytoset.split('_')
self.settings.setValue('City', citytosetlist[0])
self.settings.setValue('Country', citytosetlist[1])
self.settings.setValue('ID', citytosetlist[2])
if prev_city not in cities_list:
cities_list.append(prev_city)
self.settings.setValue('CityList', cities_list)
logging.debug(cities_list)
self.refresh()
def empty_cities_list(self):
self.citiesMenu.addAction(self.tr('Empty list'))
def refresh(self):
self.inerror = False
self.window_visible = False
self.systray.setIcon(QIcon(':/noicon'))
if hasattr(self, 'overviewcity'):
# if visible, it has to ...remain visible
# (try reason) Prevent C++ wrapper error
try:
if not self.overviewcity.isVisible():
# kills the reference to overviewcity
# in order to be refreshed
self.overviewcity.close()
del self.overviewcity
else:
self.overviewcity.close()
self.window_visible = True
except:
pass
self.systray.setToolTip(self.tr('Fetching weather data ...'))
self.city = self.settings.value('City') or ''
self.id_ = self.settings.value('ID') or None
if self.id_ is None:
# Clear the menu, no cities configured
self.citiesMenu.clear()
self.empty_cities_list()
# Sometimes self.overviewcity is in namespace but deleted
try:
self.overviewcity.close()
except:
e = sys.exc_info()[0]
logging.error('Error closing overviewcity: ' + str(e))
pass
self.timer.singleShot(2000, self.firsttime)
self.id_ = ''
self.systray.setToolTip(self.tr('No city configured'))
return
# A city has been found, create the cities menu now
self.cities_menu()
self.country = self.settings.value('Country') or ''
self.unit = self.settings.value('Unit') or 'metric'
self.suffix = ('&mode=xml&units=' + self.unit + self.appid)
self.interval = int(self.settings.value('Interval') or 30)*60*1000
self.timer.start(self.interval)
self.update()
def firsttime(self):
self.temp = ''
self.wIcon = QPixmap(':/noicon')
self.systray.showMessage(
'meteo-qt:\n', self.tr('No city has been configured yet.') +
'\n' + self.tr('Right click on the icon and click on Settings.'))
def update(self):
if hasattr(self, 'downloadThread'):
if self.downloadThread.isRunning():
logging.debug('remaining thread...')
return
logging.debug('Update...')
self.icon_loading()
self.wIcon = QPixmap(':/noicon')
self.downloadThread = Download(
self.wIconUrl, self.baseurl, self.forecast_url,
self.day_forecast_url, self.id_, self.suffix)
self.downloadThread.wimage['PyQt_PyObject'].connect(self.makeicon)
self.downloadThread.finished.connect(self.tray)
self.downloadThread.xmlpage['PyQt_PyObject'].connect(self.weatherdata)
self.downloadThread.forecast_rawpage.connect(self.forecast)
self.downloadThread.day_forecast_rawpage.connect(self.dayforecast)
self.downloadThread.uv_signal.connect(self.uv)
self.downloadThread.error.connect(self.error)
self.downloadThread.done.connect(self.done, Qt.QueuedConnection)
self.downloadThread.start()
def uv(self, value):
self.uv_coord = value
def forecast(self, data):
self.forecast_data = data
def dayforecast(self, data):
self.dayforecast_data = data
def instance_overviewcity(self):
try:
self.inerror = False
if hasattr(self, 'overviewcity'):
logging.debug('Deleting overviewcity instance...')
del self.overviewcity
self.overviewcity = overview.OverviewCity(
self.weatherDataDico, self.wIcon, self.forecast_data,
self.dayforecast_data, self.unit, self.forecast_icon_url,
self.uv_coord, self)
self.overviewcity.closed_status_dialogue.connect(self.remove_object)
except:
self.inerror = True
e = sys.exc_info()[0]
logging.error('Error: ' + str(e))
logging.debug('Try to create the city overview...\nAttempts: ' +
str(self.tentatives))
return 'error'
def remove_object(self):
del self.overviewcity
def done(self, done):
if done == 0:
self.inerror = False
elif done == 1:
self.inerror = True
logging.debug('Trying to retrieve data ...')
self.timer.singleShot(10000, self.try_again)
return
if hasattr(self, 'updateicon'):
# Keep a reference of the image to update the icon in overview
self.wIcon = self.updateicon
if hasattr(self, 'forecast_data'):
if hasattr(self, 'overviewcity'):
# Update also the overview dialog if open
if self.overviewcity.isVisible():
# delete dialog to prevent memory leak
self.overviewcity.close()
self.instance_overviewcity()
self.overview()
elif self.window_visible is True:
self.instance_overviewcity()
self.overview()
else:
self.inerror = True
self.try_create_overview()
else:
self.try_again()
def try_create_overview(self):
logging.debug('Tries to create overview :' + str(self.tentatives))
instance = self.instance_overviewcity()
if instance == 'error':
self.inerror = True
self.refresh()
else:
self.tentatives = 0
self.inerror = False
self.tooltip_weather()
def try_again(self):
self.nodata_message()
logging.debug('Attempts: ' + str(self.tentatives))
self.tentatives += 1
self.timer.singleShot(5000, self.refresh)
def nodata_message(self):
nodata = QCoreApplication.translate(
"Tray icon", "Searching for weather data...",
"Tooltip (when mouse over the icon")
self.systray.setToolTip(nodata)
self.notification = nodata
def error(self, error):
logging.error('Error:\n' + str(error))
self.nodata_message()
self.timer.start(self.interval)
self.inerror = True
def makeicon(self, data):
image = QImage()
image.loadFromData(data)
self.wIcon = QPixmap(image)
# Keep a reference of the image to update the icon in overview
self.updateicon = self.wIcon
def weatherdata(self, tree):
if self.inerror:
return
self.tempFloat = tree[1].get('value')
self.temp = ' ' + str(round(float(self.tempFloat))) + '°'
self.temp_decimal = '{0:.1f}'.format(float(self.tempFloat)) + '°'
self.meteo = tree[8].get('value')
meteo_condition = tree[8].get('number')
try:
self.meteo = self.conditions[meteo_condition]
except:
logging.debug('Cannot find localisation string for'
'meteo_condition:' + str(meteo_condition))
pass
clouds = tree[5].get('name')
clouds_percent = tree[5].get('value') + '%'
try:
clouds = self.clouds[clouds]
clouds = self.conditions[clouds]
except:
logging.debug('Cannot find localisation string for clouds:' +
str(clouds))
pass
wind = tree[4][0].get('name').lower()
try:
wind = self.wind[wind]
wind = self.conditions[wind]
except:
logging.debug('Cannot find localisation string for wind:' +
str(wind))
pass
wind_codes = tree[4][2].get('code')
try:
wind_codes = self.wind_codes[wind_codes]
except:
logging.debug('Cannot find localisation string for wind_codes:' +
str(wind_codes))
pass
wind_dir = tree[4][2].get('name')
try:
wind_dir = self.wind_dir[tree[4][2].get('code')]
except:
logging.debug('Cannot find localisation string for wind_dir:' +
str(wind_dir))
pass
self.city_weather_info = (self.city + ' ' + self.country + ' ' +
self.temp_decimal + ' ' + self.meteo)
self.tooltip_weather()
self.notification = self.city_weather_info
self.weatherDataDico['City'] = self.city
self.weatherDataDico['Country'] = self.country
self.weatherDataDico['Temp'] = self.tempFloat + '°'
self.weatherDataDico['Meteo'] = self.meteo
self.weatherDataDico['Humidity'] = (tree[2].get('value'),
tree[2].get('unit'))
self.weatherDataDico['Wind'] = (
tree[4][0].get('value'), wind, str(int(float(tree[4][2].get('value')))),
wind_codes, wind_dir)
self.weatherDataDico['Clouds'] = (clouds_percent + ' ' + clouds)
self.weatherDataDico['Pressure'] = (tree[3].get('value'),
tree[3].get('unit'))
self.weatherDataDico['Humidity'] = (tree[2].get('value'),
tree[2].get('unit'))
self.weatherDataDico['Sunrise'] = tree[0][2].get('rise')
self.weatherDataDico['Sunset'] = tree[0][2].get('set')
rain_value = tree[7].get('value')
if rain_value == None:
rain_value = ''
self.weatherDataDico['Precipitation'] = (tree[7].get('mode'), rain_value)
def tooltip_weather(self):
self.systray.setToolTip(self.city_weather_info)
def tray(self):
temp_decimal = eval(self.settings.value('Decimal') or 'False')
try:
if temp_decimal:
temp_tray = self.temp_decimal
else:
temp_tray = self.temp
except:
# First time launch
return
if self.inerror or not hasattr(self, 'temp'):
logging.critical('Cannot paint icon!')
if hasattr(self, 'overviewcity'):
try:
# delete dialog to prevent memory leak
self.overviewcity.close()
except:
pass
return
try:
self.gif_loading.stop()
except:
# In first time run the gif is not animated
pass
logging.debug('Paint tray icon...')
# Place empty.png here to initialize the icon
# don't paint the T° over the old value
icon = QPixmap(':/empty')
self.traycolor = self.settings.value('TrayColor') or ''
self.fontsize = self.settings.value('FontSize') or '18'
self.tray_type = self.settings.value('TrayType') or 'icon&temp'
pt = QPainter()
pt.begin(icon)
if self.tray_type != 'temp':
pt.drawPixmap(0, -12, 64, 64, self.wIcon)
pt.setFont(QFont('sans-sertif', int(self.fontsize)))
pt.setPen(QColor(self.traycolor))
if self.tray_type == 'icon&temp':
pt.drawText(icon.rect(), Qt.AlignBottom | Qt.AlignCenter,
str(temp_tray))
if self.tray_type == 'temp':
pt.drawText(icon.rect(), Qt.AlignCenter, str(temp_tray))
pt.end()
if self.tray_type == 'icon':
self.systray.setIcon(QIcon(self.wIcon))
else:
self.systray.setIcon(QIcon(icon))
try:
if not self.overviewcity.isVisible():
notifier = self.settings.value('Notifications') or 'True'
notifier = eval(notifier)
if notifier:
temp = int(re.search('\d+', self.temp_decimal).group())
if temp != self.notification_temp or self.id_ != self.notifications_id:
self.notifications_id = self.id_
self.notification_temp = temp
self.systray.showMessage('meteo-qt', self.notification)
except:
logging.debug('OverviewCity has been deleted' +
'Download weather information again...')
self.try_again()
return
self.restore_city()
self.tentatives = 0
self.tooltip_weather()
logging.info('Actual weather status for: ' + self.notification)
def restore_city(self):
if self.temporary_city_status:
logging.debug('Restore the default settings (city)' +
'Forget the temporary city...')
for e in ('ID', self.id_2), ('City', self.city2), ('Country', self.country2):
self.citydata(e)
self.temporary_city_status = False
def activate(self, reason):
if reason == 3:
if self.inerror or self.id_ is None or self.id_ == '':
return
try:
if hasattr(self, 'overviewcity') and self.overviewcity.isVisible():
self.overviewcity.hide()
else:
self.overviewcity.hide()
# If dialog closed by the "X"
self.done(0)
self.overview()
except:
self.done(0)
self.overview()
elif reason == 1:
self.menu.popup(QCursor.pos())
def overview(self):
if self.inerror or len(self.weatherDataDico) == 0:
return
self.overviewcity.show()
def config_save(self):
logging.debug('Config saving...')
city = self.settings.value('City'),
id_ = self.settings.value('ID')
country = self.settings.value('Country')
unit = self.settings.value('Unit')
traycolor = self.settings.value('TrayColor')
tray_type = self.settings.value('TrayType')
fontsize = self.settings.value('FontSize')
language = self.settings.value('Language')
decimal = self.settings.value('Decimal')
self.appid = '&APPID=' + self.settings.value('APPID') or ''
if language != self.language and language is not None:
self.systray.showMessage('meteo-qt:',QCoreApplication.translate(
"System tray notification",
"The application has to be restarted to apply the language setting", ''))
self.language = language
# Check if update is needed
if traycolor is None:
traycolor = ''
if (self.traycolor != traycolor or self.tray_type != tray_type or
self.fontsize != fontsize or decimal != self.temp_decimal):
self.tray()
if (city[0] == self.city and
id_ == self.id_ and
country == self.country and
unit == self.unit):
return
else:
logging.debug('Apply changes from settings...')
self.refresh()
def config(self):
dialog = settings.MeteoSettings(self.accurate_url, self.appid, self)
dialog.applied_signal.connect(self.config_save)
if dialog.exec_() == 1:
self.config_save()
logging.debug('Update Cities menu...')
self.cities_menu()
def tempcity(self):
# Prevent to register a temporary city
# This happen when a temporary city is still loading
self.restore_city()
dialog = searchcity.SearchCity(self.accurate_url, self.appid, self)
self.id_2, self.city2, self.country2 = (self.settings.value('ID'),
self.settings.value('City'),
self.settings.value('Country'))
dialog.id_signal[tuple].connect(self.citydata)
dialog.city_signal[tuple].connect(self.citydata)
dialog.country_signal[tuple].connect(self.citydata)
if dialog.exec_():
self.temporary_city_status = True
self.systray.setToolTip(self.tr('Fetching weather data...'))
self.refresh()
def citydata(self, what):
self.settings.setValue(what[0], what[1])
logging.debug('write ' + str(what[0]) + ' ' + str(what[1]))
def about(self):
title = self.tr("""<b>meteo-qt</b> v{0}
<br/>License: GPLv3
<br/>Python {1} - Qt {2} - PyQt {3} on {4}""").format(
__version__, platform.python_version(),
QT_VERSION_STR, PYQT_VERSION_STR, platform.system())
image = ':/logo'
text = self.tr("""<p>Author: Dimitrios Glentadakis <a href="mailto:[email protected]">[email protected]</a>
<p>A simple application showing the weather status
information on the system tray.
<p>Website: <a href="https://github.com/dglent/meteo-qt">
https://github.com/dglent/meteo-qt</a>
<br/>Data source: <a href="http://openweathermap.org/">
OpenWeatherMap</a>.
<br/>This software uses icons from the
<a href="http://www.kde.org/">Oxygen Project</a>.
<p>To translate meteo-qt in your language or contribute to
current translations, you can use the
<a href="https://www.transifex.com/projects/p/meteo-qt/">
Transifex</a> platform.
<p>If you want to report a dysfunction or a suggestion,
feel free to open an issue in <a href="https://github.com/dglent/meteo-qt/issues">
github</a>.""")
contributors = QCoreApplication.translate("About dialog", """
Pavel Fric<br/>
[cs] Czech translation
<p>Jürgen <a href="mailto:[email protected]">[email protected]</a><br/>
[de] German translation
<p>Peter Mattern <a href="mailto:[email protected]">[email protected]</a><br/>
[de] German translation, Project
<p>Dimitrios Glentadakis <a href="mailto:[email protected]">[email protected]</a><br/>
[el] Greek translation
<p>Ozkar L. Garcell <a href="mailto:[email protected]">[email protected]</a><br/>
[es] Spanish translation
<p>Laurene Albrand <a href="mailto:[email protected]">[email protected]</a><br/>
[fr] French translation
<p>Rémi Verschelde <a href="mailto:[email protected]">[email protected]</a><br/>
[fr] French translation, Project
<p>Daniel Napora <a href="mailto:[email protected]">[email protected]</a><br/>
Tomasz Przybył <a href="mailto:[email protected]">[email protected]</a><br/>
[pl] Polish translation
<p>Artem Vorotnikov <a href="mailto:[email protected]">[email protected]</a><br/>
[ru] Russian translation
<p>Atilla Öntaş <a href="mailto:[email protected]">[email protected]</a><br/>
[tr] Turkish translation
<p>Yuri Chornoivan <a href="mailto:[email protected]">[email protected]</a><br/>
[uk] Ukrainian translation
<p>You-Cheng Hsieh <a href="mailto:[email protected]">[email protected]</a><br/>
[zh_TW] Chinese (Taiwan) translation
<p>pmav99<br/>
Project""", "List of contributors")
dialog = about_dlg.AboutDialog(title, text, image, contributors, self)
dialog.exec_()
class FileViewWindow(QMainWindow):
def __init__(self, controller: 'Controller') -> None:
super().__init__()
self._message_area: Optional[MessageArea] = None
self.controller = controller
self.actions = self.controller.actions
self.make_window()
self.make_menubar()
self.make_toolbar()
self.addToolBarBreak()
self.make_location_toolbar()
self.make_filter_toolbar()
self.make_search_toolbar()
self.make_shortcut()
self.file_view.setFocus()
self.resize(1024, 768)
self.move(QCursor.pos().x() - self.width() / 2,
QCursor.pos().y() - self.height() / 2)
self.addAction(self.actions.rename)
def closeEvent(self, ev):
self.controller.on_exit()
def make_shortcut(self):
shortcut = QShortcut(QKeySequence(Qt.CTRL + Qt.Key_L), self)
shortcut.setContext(Qt.WindowShortcut)
shortcut.activated.connect(self.controller.show_location_toolbar)
def show_filter():
self.file_filter.setFocus(Qt.ShortcutFocusReason)
self.filter_toolbar.show()
shortcut = QShortcut(QKeySequence(Qt.CTRL + Qt.Key_K), self)
shortcut.setContext(Qt.WindowShortcut)
shortcut.activated.connect(show_filter)
shortcut = QShortcut(QKeySequence(Qt.Key_F3), self)
shortcut.setContext(Qt.WindowShortcut)
shortcut.activated.connect(self.controller.show_search)
shortcut = QShortcut(QKeySequence(Qt.CTRL + Qt.Key_F), self)
shortcut.setContext(Qt.WindowShortcut)
shortcut.activated.connect(self.controller.show_search)
shortcut = QShortcut(QKeySequence(Qt.CTRL + Qt.Key_W), self)
shortcut.setContext(Qt.WindowShortcut)
shortcut.activated.connect(self.controller.close_window)
shortcut = QShortcut(QKeySequence(Qt.ALT + Qt.Key_Up), self)
shortcut.setContext(Qt.WindowShortcut)
shortcut.activated.connect(self.controller.parent_directory)
shortcut = QShortcut(Qt.Key_Home, self)
shortcut.setContext(Qt.WindowShortcut)
shortcut.activated.connect(lambda: self.file_view.ensureVisible(0, 0, 1, 1))
shortcut = QShortcut(Qt.Key_End, self)
shortcut.setContext(Qt.WindowShortcut)
shortcut.activated.connect(
lambda: self.file_view.ensureVisible(
0, self.file_view._layout.get_bounding_rect().height(), 1, 1))
shortcut = QShortcut(Qt.Key_PageUp, self)
shortcut.setContext(Qt.WindowShortcut)
shortcut.activated.connect(lambda: self.file_view.scroll_by(0, -self.file_view.viewport().height()))
shortcut = QShortcut(Qt.Key_PageDown, self)
shortcut.setContext(Qt.WindowShortcut)
shortcut.activated.connect(lambda: self.file_view.scroll_by(0, self.file_view.viewport().height()))
def make_window(self):
self.setWindowTitle("dt-fileview")
self.setWindowIcon(QIcon(resource_filename("dirtools", "fileview/dt-fileview.svg")))
self.vbox = QVBoxLayout()
self.vbox.setContentsMargins(0, 0, 0, 0)
self.file_view = FileView(self.controller)
self.search_lineedit = SearchLineEdit(self.controller)
self.location_lineedit = LocationLineEdit(self.controller)
self.location_buttonbar = LocationButtonBar(self.controller)
self.file_filter = FilterLineEdit(self.controller)
# self.file_filter.setText("File Pattern Here")
self.file_view.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.status_bar = self.statusBar()
self.info = QLabel("")
self.status_bar.addPermanentWidget(self.info)
self.vbox.addWidget(self.file_view, Qt.AlignLeft)
self._message_area = MessageArea()
self._message_area.hide()
self.vbox.addWidget(self._message_area)
vbox_widget = QWidget()
vbox_widget.setLayout(self.vbox)
self.setCentralWidget(vbox_widget)
def hide_filter(self):
self.filter_toolbar.hide()
def make_filter_toolbar(self):
hbox = QHBoxLayout()
form = QFormLayout()
label = QLabel("Filter:")
label.setBuddy(self.file_filter)
form.addRow(label, self.file_filter)
form.setContentsMargins(0, 0, 0, 0)
hbox.addLayout(form)
help_button = QPushButton("Help")
help_button.clicked.connect(self.controller.show_filter_help)
hbox.addWidget(help_button)
hbox.setContentsMargins(0, 0, 0, 0)
widget = QWidget()
widget.setLayout(hbox)
self.filter_toolbar = QToolBar("Filter")
self.filter_toolbar.addWidget(widget)
self.addToolBar(Qt.BottomToolBarArea, self.filter_toolbar)
self.filter_toolbar.hide()
def make_search_toolbar(self):
hbox = QHBoxLayout()
form = QFormLayout()
label = QLabel("Search:")
label.setBuddy(self.search_lineedit)
form.addRow(label, self.search_lineedit)
form.setContentsMargins(0, 0, 0, 0)
hbox.addLayout(form)
help_button = QPushButton("Help")
help_button.clicked.connect(self.controller.show_search_help)
hbox.addWidget(help_button)
hbox.setContentsMargins(0, 0, 0, 0)
widget = QWidget()
widget.setLayout(hbox)
self.search_toolbar = QToolBar("Search")
self.search_toolbar.addWidget(widget)
self.addToolBar(Qt.TopToolBarArea, self.search_toolbar)
self.search_toolbar.hide()
def make_location_toolbar(self):
self.location_toolbar = self.addToolBar("Location")
widget = QWidget()
form = QFormLayout()
label = Label("Location:")
label.clicked.connect(self.controller.show_location_toolbar)
def show_location_menu(pos):
self.controller.on_context_menu(label.mapToGlobal(pos))
label.setContextMenuPolicy(Qt.CustomContextMenu)
label.customContextMenuRequested.connect(show_location_menu)
both = QVBoxLayout()
both.addWidget(self.location_buttonbar)
both.addWidget(self.location_lineedit)
form.addRow(label, both)
form.setContentsMargins(0, 0, 0, 0)
widget.setLayout(form)
self.location_toolbar.addWidget(widget)
self.addToolBarBreak(Qt.TopToolBarArea)
def make_group_menu(self):
menu = QMenu("Group Options")
menu.addAction(self.actions.group_by_none)
menu.addAction(self.actions.group_by_day)
menu.addAction(self.actions.group_by_directory)
menu.addAction(self.actions.group_by_duration)
return menu
def make_sort_menu(self):
menu = QMenu("Sort Options")
menu.addSeparator().setText("Sort Options")
menu.addAction(self.actions.sort_directories_first)
menu.addAction(self.actions.sort_reversed)
menu.addSeparator().setText("Sort by")
menu.addAction(self.actions.sort_by_name)
menu.addAction(self.actions.sort_by_size)
menu.addAction(self.actions.sort_by_ext)
menu.addAction(self.actions.sort_by_date)
menu.addAction(self.actions.sort_by_duration)
menu.addAction(self.actions.sort_by_aspect_ratio)
menu.addAction(self.actions.sort_by_framerate)
menu.addAction(self.actions.sort_by_area)
menu.addAction(self.actions.sort_by_user)
menu.addAction(self.actions.sort_by_group)
menu.addAction(self.actions.sort_by_permission)
menu.addAction(self.actions.sort_by_random)
return menu
def make_view_menu(self):
menu = QMenu("View Options")
menu.addSeparator().setText("View Options")
menu.addAction(self.actions.show_abspath)
menu.addAction(self.actions.show_basename)
menu.addSeparator()
menu.addAction(self.actions.toggle_timegaps)
return menu
def make_menubar(self):
self.menubar = self.menuBar()
file_menu = self.menubar.addMenu('&File')
file_menu.addAction(self.actions.new_window)
file_menu.addAction(self.actions.parent_directory)
file_menu.addAction(self.actions.debug)
file_menu.addAction(self.actions.save_as)
file_menu.addSeparator()
file_menu.addAction(self.actions.exit)
edit_menu = self.menubar.addMenu('&Edit')
# edit_menu.addAction(self.actions.undo)
# edit_menu.addAction(self.actions.redo)
# edit_menu.addSeparator()
edit_menu.addAction(self.actions.edit_cut)
edit_menu.addAction(self.actions.edit_copy)
edit_menu.addAction(self.actions.edit_paste)
edit_menu.addSeparator()
edit_menu.addAction(self.actions.edit_select_all)
edit_menu.addSeparator()
edit_menu.addAction(self.actions.show_preferences)
view_menu = self.menubar.addMenu('&View')
view_menu.addSeparator().setText("View Style")
view_menu.addAction(self.actions.view_detail_view)
view_menu.addAction(self.actions.view_icon_view)
view_menu.addAction(self.actions.view_small_icon_view)
view_menu.addSeparator().setText("Filter")
view_menu.addAction(self.actions.show_hidden)
view_menu.addAction(self.actions.show_filtered)
view_menu.addSeparator().setText("Path Options")
view_menu.addAction(self.actions.show_abspath)
view_menu.addAction(self.actions.show_basename)
view_menu.addSeparator().setText("Sort Options")
view_menu.addAction(self.actions.sort_directories_first)
view_menu.addAction(self.actions.sort_reversed)
view_menu.addAction(self.actions.sort_by_name)
view_menu.addAction(self.actions.sort_by_size)
view_menu.addAction(self.actions.sort_by_ext)
view_menu.addAction(self.actions.sort_by_duration)
view_menu.addAction(self.actions.sort_by_aspect_ratio)
view_menu.addAction(self.actions.sort_by_framerate)
view_menu.addAction(self.actions.sort_by_area)
view_menu.addAction(self.actions.sort_by_user)
view_menu.addAction(self.actions.sort_by_group)
view_menu.addAction(self.actions.sort_by_permission)
view_menu.addAction(self.actions.sort_by_random)
view_menu.addSeparator().setText("Zoom")
view_menu.addAction(self.actions.zoom_in)
view_menu.addAction(self.actions.zoom_out)
view_menu.addSeparator()
self.bookmarks_menu = Menu('&Bookmarks')
self.menubar.addMenu(self.bookmarks_menu)
def create_bookmarks_menu():
bookmarks = self.controller.app.bookmarks
entries = bookmarks.get_entries()
self.bookmarks_menu.clear()
if self.controller.location is None:
action = self.bookmarks_menu.addAction(QIcon.fromTheme("user-bookmarks"), "Can't bookmark file lists")
action.setEnabled(False)
elif self.controller.location in entries:
self.bookmarks_menu.addAction(
QIcon.fromTheme("edit-delete"), "Remove This Location's Bookmark",
lambda loc=self.controller.location:
bookmarks.remove(loc))
else:
self.bookmarks_menu.addAction(
QIcon.fromTheme("bookmark-new"), "Bookmark This Location",
lambda loc=self.controller.location:
bookmarks.append(loc))
self.bookmarks_menu.addSeparator()
self.bookmarks_menu.addDoubleAction(
QIcon.fromTheme("folder"), "View Bookmarks",
lambda: self.controller.set_location(Location("bookmarks", "/", [])),
lambda: self.controller.new_controller().set_location(Location("bookmarks", "/", [])))
self.bookmarks_menu.addSeparator()
icon = QIcon.fromTheme("folder")
for entry in entries:
action = self.bookmarks_menu.addDoubleAction(
icon, entry.as_url(),
lambda entry=entry: self.controller.set_location(entry),
lambda entry=entry: self.controller.app.show_location(entry))
if not entry.exists():
action.setEnabled(False)
self.bookmarks_menu.aboutToShow.connect(create_bookmarks_menu)
self.history_menu = Menu('&History')
self.menubar.addMenu(self.history_menu)
def create_history_menu():
history = self.controller.app.location_history
self.history_menu.clear()
self.history_menu.addAction(self.actions.back)
self.history_menu.addAction(self.actions.forward)
self.history_menu.addSeparator()
self.history_menu.addDoubleAction(
QIcon.fromTheme("folder"), "View File History",
self.controller.show_file_history,
lambda: self.controller.new_controller().show_file_history())
self.history_menu.addSection("Location History")
entries = history.get_unique_entries(35)
make_history_menu_entries(self.controller, self.history_menu, entries)
self.history_menu.aboutToShow.connect(create_history_menu)
help_menu = self.menubar.addMenu('&Help')
help_menu.addAction(self.actions.about)
def make_toolbar(self):
self.toolbar = self.addToolBar("FileView")
button = ToolButton()
button.setDefaultAction(self.actions.parent_directory)
button.sig_middle_click.connect(lambda: self.controller.parent_directory(new_window=True))
button.setIcon(self.actions.parent_directory.icon())
self.toolbar.addWidget(button)
self.toolbar.addSeparator()
self.toolbar.addAction(self.actions.home)
self.toolbar.addSeparator()
history_back_btn = ToolButton()
history_back_btn.setDefaultAction(self.actions.back)
history_back_btn.setContextMenuPolicy(Qt.CustomContextMenu)
history_back_btn.customContextMenuRequested.connect(
lambda pos: self.controller.show_history_context_menu(history_back_btn, False))
self.toolbar.addWidget(history_back_btn)
history_forward_btn = ToolButton()
history_forward_btn.setDefaultAction(self.actions.forward)
history_forward_btn.setContextMenuPolicy(Qt.CustomContextMenu)
history_forward_btn.customContextMenuRequested.connect(
lambda pos: self.controller.show_history_context_menu(history_forward_btn, False))
self.toolbar.addWidget(history_forward_btn)
self.toolbar.addSeparator()
self.toolbar.addAction(self.actions.reload)
self.toolbar.addAction(self.actions.prepare)
# self.toolbar.addSeparator()
# self.toolbar.addAction(self.actions.undo)
# self.toolbar.addAction(self.actions.redo)
self.toolbar.addSeparator()
self.toolbar.addAction(self.actions.show_hidden)
button = QToolButton()
button.setIcon(QIcon.fromTheme("view-restore"))
button.setMenu(self.make_view_menu())
button.setPopupMode(QToolButton.InstantPopup)
self.toolbar.addWidget(button)
button = QToolButton()
button.setIcon(QIcon.fromTheme("view-sort-ascending"))
button.setMenu(self.make_sort_menu())
button.setPopupMode(QToolButton.InstantPopup)
self.toolbar.addWidget(button)
button = QToolButton()
button.setIcon(QIcon.fromTheme("view-sort-ascending"))
button.setMenu(self.make_group_menu())
button.setPopupMode(QToolButton.InstantPopup)
self.toolbar.addWidget(button)
self.toolbar.addSeparator()
self.toolbar.addAction(self.actions.view_icon_view)
self.toolbar.addAction(self.actions.view_small_icon_view)
self.toolbar.addAction(self.actions.view_detail_view)
self.toolbar.addSeparator()
self.toolbar.addAction(self.actions.zoom_in)
self.toolbar.addAction(self.actions.zoom_out)
self.toolbar.addSeparator()
self.toolbar.addAction(self.actions.lod_in)
self.toolbar.addAction(self.actions.lod_out)
self.toolbar.addSeparator()
self.toolbar.addAction(self.actions.crop_thumbnails)
# Spacer to force right alignment for all following widget
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.toolbar.addWidget(spacer)
self.toolbar.addAction(self.actions.debug)
self.toolbar.addAction(self.controller.app.actions.enable_filesystem)
# Loading icon
self.loading_movie = QMovie(resource_filename("dirtools", "fileview/icons/gears.gif"))
self.loading_label = QLabel()
self.toolbar.addWidget(self.loading_label)
def show_loading(self):
self.show_info("Loading...")
self.loading_label.setMovie(self.loading_movie)
self.loading_movie.start()
self.loading_label.show()
def hide_loading(self):
self.show_info("")
self.loading_movie.stop()
self.loading_label.setMovie(None)
self.loading_label.setVisible(False)
def zoom_in(self):
self.file_view.zoom_in()
def zoom_out(self):
self.file_view.zoom_out()
def set_location(self, location: Location):
self.location_lineedit.set_location(location)
self.location_buttonbar.set_location(location)
self.setWindowTitle("{} - dt-fileview".format(location.as_human()))
def set_file_list(self):
self.location_lineedit.set_unused_text()
def show_info(self, text):
self.info.setText(" " + text)
def show_current_filename(self, filename):
# FIXME: this causes quite substantial keyboard lag when
# scrolling with PageUp/Down
self.status_bar.showMessage(filename)
class MoviePlayer(QWidget):
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 open(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Open a Movie",
self.currentMovieDirectory)
if fileName:
self.openFile(fileName)
def openFile(self, fileName):
self.currentMovieDirectory = QFileInfo(fileName).path()
self.movie.stop()
self.movieLabel.setMovie(self.movie)
self.movie.setFileName(fileName)
self.movie.start()
self.updateFrameSlider();
self.updateButtons();
def goToFrame(self, frame):
self.movie.jumpToFrame(frame)
def fitToWindow(self):
self.movieLabel.setScaledContents(self.fitCheckBox.isChecked())
def updateFrameSlider(self):
hasFrames = (self.movie.currentFrameNumber() >= 0)
if hasFrames:
if self.movie.frameCount() > 0:
self.frameSlider.setMaximum(self.movie.frameCount() - 1)
elif self.movie.currentFrameNumber() > self.frameSlider.maximum():
self.frameSlider.setMaximum(self.movie.currentFrameNumber())
self.frameSlider.setValue(self.movie.currentFrameNumber())
else:
self.frameSlider.setMaximum(0)
self.frameLabel.setEnabled(hasFrames)
self.frameSlider.setEnabled(hasFrames)
def updateButtons(self):
state = self.movie.state()
self.playButton.setEnabled(self.movie.isValid() and
self.movie.frameCount() != 1 and state == QMovie.NotRunning)
self.pauseButton.setEnabled(state != QMovie.NotRunning)
self.pauseButton.setChecked(state == QMovie.Paused)
self.stopButton.setEnabled(state != QMovie.NotRunning)
def createControls(self):
self.fitCheckBox = QCheckBox("Fit to Window")
self.frameLabel = QLabel("Current frame:")
self.frameSlider = QSlider(Qt.Horizontal)
self.frameSlider.setTickPosition(QSlider.TicksBelow)
self.frameSlider.setTickInterval(10)
speedLabel = QLabel("Speed:")
self.speedSpinBox = QSpinBox()
self.speedSpinBox.setRange(1, 9999)
self.speedSpinBox.setValue(100)
self.speedSpinBox.setSuffix("%")
self.controlsLayout = QGridLayout()
self.controlsLayout.addWidget(self.fitCheckBox, 0, 0, 1, 2)
self.controlsLayout.addWidget(self.frameLabel, 1, 0)
self.controlsLayout.addWidget(self.frameSlider, 1, 1, 1, 2)
self.controlsLayout.addWidget(speedLabel, 2, 0)
self.controlsLayout.addWidget(self.speedSpinBox, 2, 1)
def createButtons(self):
iconSize = QSize(36, 36)
openButton = QToolButton()
openButton.setIcon(self.style().standardIcon(QStyle.SP_DialogOpenButton))
openButton.setIconSize(iconSize)
openButton.setToolTip("Open File")
openButton.clicked.connect(self.open)
self.playButton = QToolButton()
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.setIconSize(iconSize)
self.playButton.setToolTip("Play")
self.playButton.clicked.connect(self.movie.start)
self.pauseButton = QToolButton()
self.pauseButton.setCheckable(True)
self.pauseButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPause))
self.pauseButton.setIconSize(iconSize)
self.pauseButton.setToolTip("Pause")
self.pauseButton.clicked.connect(self.movie.setPaused)
self.stopButton = QToolButton()
self.stopButton.setIcon(self.style().standardIcon(QStyle.SP_MediaStop))
self.stopButton.setIconSize(iconSize)
self.stopButton.setToolTip("Stop")
self.stopButton.clicked.connect(self.movie.stop)
quitButton = QToolButton()
quitButton.setIcon(self.style().standardIcon(QStyle.SP_DialogCloseButton))
quitButton.setIconSize(iconSize)
quitButton.setToolTip("Quit")
quitButton.clicked.connect(self.close)
self.buttonsLayout = QHBoxLayout()
self.buttonsLayout.addStretch()
self.buttonsLayout.addWidget(openButton)
self.buttonsLayout.addWidget(self.playButton)
self.buttonsLayout.addWidget(self.pauseButton)
self.buttonsLayout.addWidget(self.stopButton)
self.buttonsLayout.addWidget(quitButton)
self.buttonsLayout.addStretch()
class XNCStatusBar(QStatusBar):
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 set_status(self, msg: str, timeout: int=0):
self.showMessage(msg, timeout)
def set_loading_status(self, loading: bool):
if loading:
self._lbl_loading.show()
self._loading_gif.start()
else:
self._loading_gif.stop()
self._lbl_loading.hide()
def set_world_load_progress(self, comment: str, progress: int):
"""
Display world load progress in status bar
:param comment: string comment of what is currently loading
:param progress: percent progress, or -1 to disable
"""
if progress != -1:
if not self._progressbar.isVisible():
self.insertPermanentWidget(0, self._progressbar)
self._progressbar.show()
msg = self.tr('Loading world') + ' ({0}%) {1}...'.format(progress, comment)
logger.debug(msg)
self._progressbar.setValue(progress)
self.set_status(msg)
else:
self.removeWidget(self._progressbar)
self._progressbar.hide()
self._progressbar.reset()
self.clearMessage()
def update_online_players_count(self):
op = self.world.get_online_players()
self._lbl_online.setText(self.tr('Online') + ': {0}'.format(op))
# some functions may be useful, documentation:
# void QStatusBar::clearMessage()
# void QStatusBar::addPermanentWidget(QWidget * widget, int stretch = 0)
# void QStatusBar::addWidget(QWidget * widget, int stretch = 0)
# void QStatusBar::removeWidget(QWidget * widget)
@pyqtSlot()
def on_run_script(self):
files = os.listdir('scripts')
files.sort()
script_files = [fn for fn in files if fn[0] != '.' and fn.endswith('.py')]
# print(script_files)
menu = QMenu(self)
for script_filename in script_files:
act = QAction(menu)
act.setText('Run "scripts/' + script_filename + '"...')
act.setData('scripts/' + script_filename)
menu.addAction(act)
act_ret = menu.exec(QCursor.pos())
if act_ret is None:
return
script_filename = str(act_ret.data())
s = ''
try:
with open(script_filename, 'rt', encoding='utf-8') as f:
s = f.read()
except IOError:
pass
if s != '':
exec(s)
