def test_normal_case(self):
app = QApplication([])
from threading import Thread
from PyQt4.QtGui import QProgressBar
import time
pg = QProgressBar()
def test_thread():
std_signal = Signal(1)
test_built_in = Signal(2)
std_signal.connect(pg.setValue)
test_built_in.connect(pg.setRange)
v_int = 0
while True:
v_int += 1
std_signal.emit(v_int)
test_built_in.emit(0, 10)
time.sleep(0.5)
if v_int == 5:
break
pg.close()
t = Thread(None, test_thread)
t.start()
pg.show()
app.exec_()
class BusyBar(QThread):
"""
Adapted from: http://stackoverflow.com/questions/8007602/
looping-qprogressbar-gives-error-qobjectinstalleventfilter-cannot-filter-e
Looping progress bar
create the signal that the thread will emit
.. note::
This function creates a busy bar but I have not figured out how to \
attach it to a process. Therefore, it is currently functionally \
useless.
"""
changeValue = pyqtSignal(int)
def __init__(self, text=""):
QThread.__init__(self, parent=None)
self.text = text
self.stop = False
self.proBar = QProgressBar()
self.proBar.setWindowFlags(Qt.WindowStaysOnTopHint | Qt.SplashScreen)
self.proBar.setRange(0, 100)
self.proBar.setTextVisible(True)
self.proBar.setFormat(self.text)
self.proBar.setValue(0)
self.proBar.setFixedSize(300, 40)
self.proBar.setAlignment(Qt.AlignCenter)
self.proBar.show()
#self.changeValue.connect(self.proBar.setValue, Qt.QueuedConnection)
# Make the Busybar delete itself and the QProgressBar when done
self.finished.connect(self.onFinished)
def run(self):
"""
"""
while not self.stop:
# keep looping while self is visible
# Loop sending mail
for i in range(100):
# emit the signal instead of calling setValue
# also we can't read the progress bar value from the thread
self.changeValue.emit(i)
time.sleep(0.01)
self.changeValue.emit(0)
def onFinished(self):
"""
"""
self.proBar.deleteLater()
self.deleteLater()
def Kill(self):
"""
"""
self.stop = True
class BusyBar(QThread):
"""
Adapted from: http://stackoverflow.com/questions/8007602/
looping-qprogressbar-gives-error-qobjectinstalleventfilter-cannot-filter-e
Looping progress bar
create the signal that the thread will emit
.. note::
This function creates a busy bar but I have not figured out how to \
attach it to a process. Therefore, it is currently functionally \
useless.
"""
changeValue = pyqtSignal(int)
def __init__(self, text = "" ):
QThread.__init__(self, parent = None)
self.text = text
self.stop = False
self.proBar = QProgressBar()
self.proBar.setWindowFlags(Qt.WindowStaysOnTopHint | Qt.SplashScreen )
self.proBar.setRange( 0, 100 )
self.proBar.setTextVisible( True )
self.proBar.setFormat( self.text )
self.proBar.setValue( 0 )
self.proBar.setFixedSize( 300 , 40 )
self.proBar.setAlignment(Qt.AlignCenter)
self.proBar.show()
#self.changeValue.connect(self.proBar.setValue, Qt.QueuedConnection)
# Make the Busybar delete itself and the QProgressBar when done
self.finished.connect(self.onFinished)
def run(self):
"""
"""
while not self.stop:
# keep looping while self is visible
# Loop sending mail
for i in range(100):
# emit the signal instead of calling setValue
# also we can't read the progress bar value from the thread
self.changeValue.emit( i )
time.sleep(0.01)
self.changeValue.emit( 0 )
def onFinished(self):
"""
"""
self.proBar.deleteLater()
self.deleteLater()
def Kill(self):
"""
"""
self.stop = True
class InputDockWidget(QDockWidget):
def __init__(self, *args):
QDockWidget.__init__(self, *args)
self.setupUi(self)
self.setWindowIcon(QIcon(':/icons/qtsixa.png'))
self.color = QColor(Qt.lightGray)
self.setMinimumWidth(350)
self.setContentsMargins(0, 0, 0, 0)
self.adjustSize()
def setupUi(self, QtSixAMainW):
QtSixAMainW.setObjectName(_fromUtf8('QtSixAMainW'))
QtSixAMainW.resize(935, 513)
triggers = TiggersView(self)
triggers.show()
bumpers = BumpersView(self)
bumpers.show()
face = FaceButtonsView(self)
face.show()
dpad = DpadView(self)
dpad.show()
select = StartSelectView(self)
select.show()
sixaxis = SixAxisView(self)
sixaxis.show()
hbox = QHBoxLayout()
hbox.addStretch(1)
hbox.addWidget(triggers)
hbox.addWidget(bumpers)
hbox.addWidget(dpad)
hbox.addWidget(face)
hbox.addWidget(select)
hbox.addWidget(sixaxis)
vbox = QVBoxLayout()
vbox.addStretch(1)
vbox.addLayout(hbox)
self.setLayout(vbox)
self.progress = QProgressBar(self)
self.progress.setGeometry(20, 2, 50, 20)
self.progress.setTextVisible(False)
self.progress.setOrientation(Qt.Vertical)
self.progress.setValue(80)
self.progress.move(60,28)
self.progress.show()
print self.style().objectName()
QApplication.setStyle(QStyleFactory.create('Cleanlooks'))
def paintEvent(self, event = None):
pass
def test_normal_case(self):
app = QApplication([])
from threading import Thread
from PyQt4.QtGui import QProgressBar
import time
pg = QProgressBar()
def test_thread():
std_signal = Signal(1)
test_built_in = Signal(2)
std_signal.connect(pg.setValue)
test_built_in.connect(pg.setRange)
v_int = 0
while True:
v_int += 1
std_signal.emit(v_int)
test_built_in.emit(0,10)
time.sleep(0.5)
if v_int == 5:
break
pg.close()
t = Thread(None,test_thread)
t.start()
pg.show()
app.exec_()
class RipperWidget(SmoothWidget, ripper.Ripper):
""" One-button multi-track ripper.
"""
def __init__(self, parent=None):
SmoothWidget.__init__(self, parent)
ripper.Ripper.__init__(self)
Layout = QVBoxLayout(self)
self.discLabel = QLabel(self)
Layout.addWidget(self.discLabel)
# ONLY ONE BUTTON!
self.button = QPushButton('Cancel', self)
self.button.setEnabled(True)
self.button.hide()
QObject.connect(self.button, SIGNAL('clicked()'),
self.cancel)
Layout.addWidget(self.button)
self.catFrame = QFrame(self)
self.catFrame.setFrameStyle(QFrame.StyledPanel)
self.catFrame.hide()
QHBoxLayout(self.catFrame)
self.categories = CategoryButtons(self.catFrame)
QObject.connect(self.categories, SIGNAL('selected(QString &)'),
self.start)
self.catFrame.layout().addWidget(self.categories)
Layout.addWidget(self.catFrame)
self.progress = QProgressBar(self)
self.progress.setRange(0, 100)
self.progress.hide()
Layout.addWidget(self.progress)
def start(self, category):
""" Should already have the track info. """
self.genre = str(category)
self._progress_data = {}
self.disc_length = 0.0
for i in range(self.count):
sec = cd_logic.get_track_time_total(i)
self._progress_data[i] = {'rip' : 0,
'enc' : 0,
'length' : sec}
self.disc_length += sec
self.rip_n_encode()
text = '%s - %s' % (self.artist, self.album)
self.discLabel.setText('Copying "'+text+'"...')
self.button.show()
self.progress.show()
self.catFrame.hide()
def cancel(self):
self.stop_request = True
path = os.path.join(ripper.LIBRARY,
self.genre,
self.artist+' - '+self.album)
os.system('rm -rf \"%s\"' % path)
self.discLabel.setText('Canceled')
self.button.hide()
self.progress.hide()
self.progress.setValue(0)
self.emit(SIGNAL('canceled()'))
def read_disc_info(self):
self.discLabel.setText('Getting disc info...')
ripper.Ripper.read_disc_info(self)
def ripper_event(self, e):
""" """
event = QEvent(event_type(e.type))
event.data = e.__dict__
QApplication.instance().postEvent(self, event)
def customEvent(self, e):
if e.type() == event_type(ripper.CDDB_DONE):
self.button.setEnabled(True)
text = '%s - %s' % (self.artist, self.album)
text += ' ( Select a category... )'
self.discLabel.setText(text)
self.catFrame.show()
self.emit(SIGNAL('foundDiscInfo()'))
elif e.type() == event_type(ripper.STATUS_UPDATE):
self.updateProgress(e.data)
self.emit(SIGNAL('status(QEvent *)'), e)
def updateProgress(self, data):
"""
assume rip and enc are equal in time.
"""
state = data['state']
tracknum = data['tracknum']
percent = data['percent']
goal_percents = self.count * 200
item = self._progress_data[tracknum]
if state == 'rip':
item['rip'] = percent
elif state == 'enc':
item['enc'] = percent
else:
# err, etc...
item['rip'] = 0
item['enc'] = 0
total = 0
for i, v in self._progress_data.items():
seconds = v['length']
rip_perc = v['rip']
enc_perc = v['enc']
worth = seconds / self.disc_length
rip_perc *= worth
enc_perc *= worth
total += rip_perc + enc_perc
#print i, worth, rip_perc, enc_perc, total
percent = total / 2
self.progress.setValue(percent)
if percent == 100:
if self.is_ripping:
print 'percent == 100 but still ripping?'
if self.is_encoding:
print 'percent == 100 but still encoding?'
else:
print 'percent == 100 and ripper finished'
self.button.hide()
self.progress.hide()
text = 'Finished copying \"%s - %s\"' % (self.artist, self.album)
self.discLabel.setText(text)
self.emit(SIGNAL('doneRipping()'))
class TabDownloads(QWidget):
instance = None
def __init__(self, search, parent=None):
QWidget.__init__(self, parent)
# Load de l'UI
PyQt4.uic.loadUi('ui/downloads.ui', self)
# Ajout de la progressBar
self.progressBar = QProgressBar()
self.progressBar.setMinimum(0)
self.progressBar.setMaximum(100)
self.progressBar.hide()
self.HLayout = QBoxLayout(QBoxLayout.LeftToRight)
self.HLayout.addWidget(self.progress_label)
self.HLayout.addWidget(self.progressBar)
self.formLayout_3.addRow(self.HLayout)
# Vars
TabDownloads.instance = self
self.downloads = Downloads()
self.pos = None
self.download_looked = None
# Affichage custom
#self.downloads_table.setStyleSheet(\
# "QTableView::item{ \
# border-right-style:solid; \
# border-width:0.5; \
# border-color: #9B9B9B; \
# }")
# On autorise la creation de menu contextuel
self.setContextMenuPolicy(Qt.CustomContextMenu)
# Signaux
self.customContextMenuRequested.connect(self.contextMenu)
self.downloads_table.itemClicked.connect(self.show_info_download)
# Init
self.load_downloads()
# On remove les finis et en erreur si Config.clean_dl_list = 1
if Configuration.clean_dl_list == 1:
self.clean_list_Action()
#########################################################
# On désactive les boutons qui sont pas encore implantés
self.button_stop_all.setEnabled(False)
self.button_resume_all.setEnabled(False)
#########################################################
def load_downloads(self):
import xml.sax
parser = xml.sax.make_parser()
parser.setContentHandler(AnalyseDownloads(self.add_downloads))
try:
for line in open(os.path.expanduser("~") + '/.pyrex/downloads.xml'):
parser.feed(line)
self.downloads.save()
except:
pass
def add_download(self, download):
# Avant de filtrer on écrit le download
#self.downloads.append(download) #TODO : pour quand on pourra resume, décommenter la ligne et ramener le save ici
if download.state == 4 or download.progress == 0:
rows = self.downloads_table.rowCount()
self.downloads_table.insertRow(rows)
self.downloads_table.setItem(rows, 0, MyQTableWidgetItem(download.file_share.name, download))
self.downloads_table.setItem(rows, 1, QTableWidgetItem(download.get_progress()))
self.downloads_table.setItem(rows, 2, QTableWidgetItem(download.state_str))
self.downloads_table.setItem(rows, 3, QTableWidgetItem("0 ko/s"))
self.downloads_table.setItem(rows, 5, QTableWidgetItem(download.date.strftime('%d/%m/%y')))
self.downloads.append(download)
# TODO : à modifier probablement quand on aura le resume pour les downloads
if download.state != 4 and download.progress == 0:
# Signaux
download.progressModified.connect(self.update_progress)
download.stateChanged.connect(self.update_state)
download.downloadFinished.connect(self.download_finished)
download.speedModified.connect(self.update_speed)
# On save
self.downloads.save()
def add_downloads(self, downloads):
for download in downloads:
self.add_download(download)
def update_progress(self, download):
item = self.downloads_table.findItems(download.file_share.name, Qt.MatchExactly)[0]
row = self.downloads_table.row(item)
self.downloads_table.item(row, 1).setText(download.get_progress())
# On update la barre de progression si on est en train de regarder un download
if self.download_looked == download:
self.progressBar.setValue(int(download.progress))
def update_speed(self, download):
item = self.downloads_table.findItems(download.file_share.name, Qt.MatchExactly)[0]
row = self.downloads_table.row(item)
self.downloads_table.item(row, 3).setText(convert_speed_str(download.speed))
def update_state(self, download):
item = self.downloads_table.findItems(download.file_share.name, Qt.MatchExactly)[0]
row = self.downloads_table.row(item)
self.downloads_table.item(row, 2).setText(download.state_str)
# On save
self.downloads.save()
def download_finished(self, download):
if download.read_bytes == download.file_share.size:
item = self.downloads_table.findItems(download.file_share.name, Qt.MatchExactly)[0]
row = self.downloads_table.row(item)
self.downloads_table.item(row, 2).setText("Finished!")
self.downloads_table.item(row, 3).setText("")
# On save
self.downloads.save()
else:
print "Erreur dans le téléchargement"
item = self.downloads_table.findItems(download.file_share.name, Qt.MatchExactly)[0]
row = self.downloads_table.row(item)
self.downloads_table.item(row, 2).setText("Error : invalid size :(")
self.downloads_table.item(row, 3).setText("")
# On save
self.downloads.save()
def contextMenu(self, pos):
self.pos = pos
menu = QMenu()
# Actions
forceAction = menu.addAction("Forcer la reprise")
continueAction = menu.addAction("Reprise")
pauseAction = menu.addAction("Pause")
openAction = menu.addAction("Ouvrir")
abortAction = menu.addAction("Annuler")
supprListeAction = menu.addAction("Supprimer de la liste")
supprDiskAction = menu.addAction("Supprimer de la liste et du disque")
copyAction = menu.addAction("Copier l'URL")
searchAction = menu.addAction("Rechercher des fichiers similaires")
# On désactive les actions s'il n'y a pas de downloads
if self.downloads == [] or self.downloads_table.currentRow() < 0:
forceAction.setEnabled(False)
continueAction.setEnabled(False)
pauseAction.setEnabled(False)
openAction.setEnabled(False)
abortAction.setEnabled(False)
supprListeAction.setEnabled(False)
supprDiskAction.setEnabled(False)
copyAction.setEnabled(False)
searchAction.setEnabled(False)
#########################################################
# On désactive les boutons qui sont pas encore implantés
forceAction.setEnabled(False)
#continueAction.setEnabled(False)
#pauseAction.setEnabled(False)
searchAction.setEnabled(False)
#########################################################
# Signaux
self.connect(forceAction, SIGNAL('triggered()'), self.force_Action)
self.connect(continueAction, SIGNAL('triggered()'), self.continue_Action)
self.connect(pauseAction, SIGNAL('triggered()'), self.pause_Action)
self.connect(openAction, SIGNAL('triggered()'), self.open_Action)
self.connect(abortAction, SIGNAL('triggered()'), self.abort_Action)
self.connect(supprListeAction, SIGNAL('triggered()'), self.suppr_liste_Action)
self.connect(supprDiskAction, SIGNAL('triggered()'), self.suppr_disk_Action)
self.connect(copyAction, SIGNAL('triggered()'), self.copy_Action)
self.connect(searchAction, SIGNAL('triggered()'), self.search_Action)
# On affiche le menu
menu.exec_(self.mapToGlobal(pos))
def getDownloads(self):
rows = self.downloads_table.selectionModel().selectedRows()
return [self.downloads_table.item(row.row(), 0).download for row in rows]
def force_Action(self):
print "TODO"
def continue_Action(self):
for download in self.getDownloads():
print "Resuming download"
download.resume()
self.display_resume_pause()
def pause_Action(self):
for download in self.getDownloads():
print "Pausing download"
download.pause()
self.display_resume_pause()
def open_Action(self):
for download in self.getDownloads():
open_file(download.local_path)
def abort_Action(self):
for download in self.getDownloads():
download.stop()
row = self.downloads_table.currentRow()
self.downloads_table.item(row, 2).setText(u"Annulé!")
self.downloads_table.item(row, 3).setText("")
def remove_download(self, download, erase):
download.stop()
row = self.downloads_table.currentRow()
# On supprime la ligne
self.downloads_table.removeRow(row)
# On supprime de la liste
self.downloads.remove(download)
# On save
self.downloads.save()
if erase:
try:
os.remove(download.local_path)
except OSError:
try:
shutil.rmtree(download.local_path)
except:
print "Erreur dans la suppression du fichier"
def suppr_liste_Action(self):
for download in self.getDownload():
self.remove_download(download, False)
def suppr_disk_Action(self):
for download in self.getDownloads():
self.remove_download(download, True)
def copy_Action(self):
pressPaper = QApplication.clipboard()
text = '\n'.join([dl.local_path for dl in self.getDownloads()])
pressPaper.setText(text)
def search_Action(self):
print "TODO"
def show_info_download(self):
download = self.getDownloads()[0]
self.name_label.setText(u"Nom : {}".format(download.file_share.name))
self.path_label.setText(u"Chemin local : {}".format(download.local_path))
self.url_label.setText(u"URL : {}".format(download.file_share.url))
self.size_label.setText(u"Taille : {}".format(download.file_share.str_size))
self.progressBar.show()
self.progressBar.setValue(int(download.progress))
self.download_looked = download
def clean_list_Action(self):
remove_list = []
for download in self.downloads:
if download.state == 4 or download.state == 7:
# On trouve la ligne
item = self.downloads_table.findItems(download.file_share.name, Qt.MatchExactly)[0]
row = self.downloads_table.row(item)
# On la supprime
self.downloads_table.removeRow(row)
# On save pour après la boucle for
remove_list.append(download)
# On supprime de la liste
for download in remove_list:
self.downloads.remove(download)
# On save
self.downloads.save()
def double_clicked(self, row, col):
download = self.getDownloads()[0]
if download:
open_file(download.local_path)
def display_resume_pause(self):
downloads = self.getDownloads()
pause = False
resume = False
if downloads:
for download in downloads:
if download.state == 5:
pause = True
else:
resume = True
self.button_pause.setEnabled(resume)
self.button_resume.setEnabled(pause)
def clicked(self, row, col):
self.display_resume_pause()
def resizeEvent(self, event):
maxSize = self.downloads_table.size().width()
# Nom Ficher : 24%
self.downloads_table.horizontalHeader().resizeSection(0, maxSize*.24)
# Avancement : 22%
self.downloads_table.horizontalHeader().resizeSection(1, maxSize*.22)
# Etat : 17%
self.downloads_table.horizontalHeader().resizeSection(2, maxSize*.17)
# Vitesse : 13%
self.downloads_table.horizontalHeader().resizeSection(3, maxSize*.13)
# Fin : 12%
self.downloads_table.horizontalHeader().resizeSection(4, maxSize*.12)
event.accept()
class Window(QMainWindow):
def __init__(self,parent = None):
QMainWindow.__init__(self,parent)
self.resize(1024,768)
self.setWindowTitle("Sabel")
self.setWindowIcon(Icons.sabel)
self.centralwidget = QWidget(self)
self.horizontalLayout = QHBoxLayout(self.centralwidget)
self.horizontalLayout.setMargin(0)
self.cmdList = config.cmds()
self.paramList = config.params()
'''A.Editor TabWidget'''
'''This parent is for findbar and vertical layout'''
self.editorLayoutWidget = QWidget(self)
self.editorLayoutWidget.setMinimumWidth(800)
self.tabWidget = EditorTab(self)
self.editorLayout = QVBoxLayout(self.editorLayoutWidget)
self.editorLayout.setMargin(0)
self.editorLayout.addWidget(self.tabWidget)
"0.Style Layout"
self.styleLayoutWidget = QFrame()
self.styleLayoutWidget.setFrameShape(QFrame.StyledPanel)
self.styleLayout = QHBoxLayout(self.styleLayoutWidget)
self.styleTest = QPushButton(self.styleLayoutWidget)
self.styleTest.setText("Change Styles")
self.styleTest.clicked.connect(self.changeStyleSheet)
self.popWidget = Popup(self.styleLayoutWidget)
self.styleLayout.addWidget(self.styleTest)
self.styleLayout.addWidget(self.popWidget)
self.styleLayout.setMargin(0)
self.editorLayout.addWidget(self.styleLayoutWidget)
self.styleLayoutWidget.hide()
"1.Find Layout"
self.findLayoutWidget = QFrame()
self.findLayoutWidget.setFrameShape(QFrame.StyledPanel)
self.findLayout = QHBoxLayout(self.findLayoutWidget)
self.lineEdit = QLineEdit(self.findLayoutWidget)
self.lineEdit_2 = QLineEdit(self.findLayoutWidget)
self.findClose = QPushButton(self.findLayoutWidget)
self.findClose.setIcon(Icons.close_view)
self.findClose.setFlat(True)
self.findClose.clicked.connect(self.findBarShow)
self.find = QPushButton(self.findLayoutWidget)
self.find.setText("Find")
self.find.clicked.connect(self.findCurrentText)
self.replacefind = QPushButton(self.findLayoutWidget)
self.replacefind.setText("Replace/Find")
self.replacefind.clicked.connect(self.replaceFindText)
self.replace = QPushButton(self.findLayoutWidget)
self.replace.setText("Replace")
self.replace.clicked.connect(self.replaceCurrentText)
self.replaceAll = QPushButton(self.findLayoutWidget)
self.replaceAll.setText("Replace All")
self.replaceAll.clicked.connect(self.replaceAllText)
self.caseSensitive = QToolButton(self.findLayoutWidget)
self.caseSensitive.setIcon(Icons.font)
self.caseSensitive.setCheckable(True)
self.wholeWord = QToolButton(self.findLayoutWidget)
self.wholeWord.setText("ww")
self.wholeWord.setCheckable(True)
self.regex = QToolButton(self.findLayoutWidget)
self.regex.setText("re")
self.regex.setCheckable(True)
self.backward = QToolButton(self.findLayoutWidget)
self.backward.setText("bk")
self.backward.setCheckable(True)
self.backward.setDisabled(True)
self.findLayout.addWidget(self.findClose)
self.findLayout.addWidget(self.find)
self.findLayout.addWidget(self.lineEdit)
self.findLayout.addWidget(self.lineEdit_2)
self.findLayout.addWidget(self.caseSensitive)
self.findLayout.addWidget(self.wholeWord)
self.findLayout.addWidget(self.regex)
self.findLayout.addWidget(self.backward)
self.findLayout.addWidget(self.replacefind)
self.findLayout.addWidget(self.replace)
self.findLayout.addWidget(self.replaceAll)
self.findLayout.setMargin(0)
self.findLayoutWidget.setMaximumHeight(25)
self.editorLayout.addWidget(self.findLayoutWidget)
self.findLayoutWidget.hide()
'''B.Designer'''
'''This parent is for widgetsbar and design layout'''
self.designerLayoutWidget = QWidget(self)
self.designerLayoutWidget.setMinimumWidth(800)
self.designerWidget = Screen(self)
self.designerLayoutWidget.hide()
self.designerLayout = QVBoxLayout(self.designerLayoutWidget)
self.designerLayout.setMargin(0)
self.designerLayout.addWidget(self.designerWidget)
'''C.Level Editor'''
'''This parent is for spritesheets and level layout'''
self.levelLayoutWidget = QWidget(self)
self.levelLayoutWidget.setMinimumWidth(800)
self.levelWidget = Level(self)
self.levelLayoutWidget.hide()
self.levelLayout = QVBoxLayout(self.levelLayoutWidget)
self.levelLayout.setMargin(0)
self.levelLayout.addWidget(self.levelWidget)
'''D.Explorer TabWidget'''
self.explorerTabWidget = TreeTab(self)
#self.explorerTabWidget.setMaximumWidth(200)
'''1.Project Tree'''
self.tab_5 = QWidget()
#self.tab_5.setMaximumWidth(200)
self.VerticalLayout_2 = QVBoxLayout(self.tab_5)#QHBoxLayout(self.tab_5)
self.VerticalLayout_2.setMargin(0)
self.treeWidget = ProjectTree(self.tab_5)
#self.treeWidget.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
#self.treeWidget.horizontalScrollBar().show()
self.VerticalLayout_2.addWidget(self.treeWidget)
'''2.Outline Tree'''
self.tab_2 = QWidget()
#self.tab_2.setMaximumWidth(200)
self.VerticalLayout_3 = QVBoxLayout(self.tab_2)
self.VerticalLayout_3.setMargin(0)
self.outlineWidget = OutlineTree(self.tab_2)
self.outlineWidget.itemDoubleClicked.connect(self.gotoLine)
self.VerticalLayout_3.addWidget(self.outlineWidget)
'''E.Output TabWidget'''
self.outputTabWidget = OutputTab(self)
self.tabWidget.currentChanged.connect(self.fileChanged)
self.explorerTabWidget.currentChanged.connect(self.closeExplorer)
self.outputTabWidget.currentChanged.connect(self.closeConsole)
self.tabWidget.setTabsClosable(True)
self.tabWidget.setTabShape(0)
'''1.Output layout'''
#must check
self.tab_6 = QWidget()
self.horizontalLayout_2 = QVBoxLayout(self.tab_6)
self.horizontalLayout_2.setMargin(0)
self.textEdit = QTextEdit()
self.inputLayout = QHBoxLayout()
self.inputLayout.setMargin(0)
self.fileButton = QPushButton()
self.fileButton.setText("File")
self.fileButton.clicked.connect(self.getFile)
self.runButton = QPushButton()
self.runButton.setFlat(True)
self.runButton.setIcon(Icons.go)
self.combo = QComboBox()
self.combo.setFixedWidth(100)
self.comboAdd = QPushButton()
self.comboAdd.setIcon(Icons.add)
self.comboAdd.setFlat(True)
self.comboAdd.clicked.connect(self.addCmd)
self.comboDel = QPushButton()
self.comboDel.setIcon(Icons.close_view)
self.comboDel.setFlat(True)
self.comboDel.clicked.connect(self.delCmd)
self.combo2 = QComboBox()
self.combo2.setFixedWidth(500)
self.combo2Add = QPushButton()
self.combo2Add.setIcon(Icons.add)
self.combo2Add.setFlat(True)
self.combo2Add.clicked.connect(self.addParam)
self.combo2Del = QPushButton()
self.combo2Del.setIcon(Icons.close_view)
self.combo2Del.setFlat(True)
self.combo2Del.clicked.connect(self.delParam)
if(self.checkHasValue(self.cmdList)):
for cmd in self.cmdList:
self.combo.addItem(cmd)
else:
self.cmdList = []
if(self.checkHasValue(self.paramList)):
for param in self.paramList:
self.combo2.addItem(param)
else:
self.paramList = []
self.horizontalLayout_2.addWidget(self.textEdit)
self.inputLayout.addWidget(QLabel("<b>Command:</b>"))
self.inputLayout.addWidget(self.combo)
self.inputLayout.addWidget(self.comboAdd)
self.inputLayout.addWidget(self.comboDel)
self.inputLayout.addWidget(QLabel("<b>Parameters:</b>"))
self.inputLayout.addWidget(self.combo2)
self.inputLayout.addWidget(self.combo2Add)
self.inputLayout.addWidget(self.combo2Del)
self.inputLayout.addWidget(self.fileButton)
self.inputLayout.addWidget(self.runButton)
self.horizontalLayout_2.addLayout(self.inputLayout)
'''2.Error Layout'''
self.tab_7 = QWidget()
self.horizontalLayout_4 = QHBoxLayout(self.tab_7)
self.horizontalLayout_4.setMargin(0)
self.errorTree = ErrorTree(self.tab_7)
self.errorTree.itemDoubleClicked.connect(self.errorLine)
self.horizontalLayout_4.addWidget(self.errorTree)
'''TabWidgets tabs'''
#self.designerWidget.addTab(QWidget(self),"")
#self.designerWidget.setTabIcon(0,Icons.close_view)
#self.levelWidget.addTab(QWidget(self),"")
#self.levelWidget.setTabIcon(0,Icons.close_view)
self.explorerTabWidget.addTab(self.tab_5,"Projects")
self.explorerTabWidget.addTab(self.tab_2,"Outline")
self.explorerTabWidget.addTab(QWidget(self),"")
self.explorerTabWidget.setTabIcon(0,Icons.cprj)
self.explorerTabWidget.setTabIcon(1,Icons.envvar)
self.explorerTabWidget.setTabIcon(2,Icons.close_view)
self.outputTabWidget.addTab(self.tab_7,"Error")
self.outputTabWidget.addTab(self.tab_6,"Output")
self.outputTabWidget.addTab(QWidget(self),"")
self.outputTabWidget.setTabIcon(0,Icons.error)
self.outputTabWidget.setTabIcon(1,Icons.console_view)
self.outputTabWidget.setTabIcon(2,Icons.close_view)
'''Splitters'''
self.split1 = QSplitter(Qt.Horizontal)
self.split1.addWidget(self.explorerTabWidget)
self.split1.addWidget(self.editorLayoutWidget)
self.split1.addWidget(self.designerLayoutWidget)
self.split1.addWidget(self.levelLayoutWidget)
#self.split1.addWidget(self.tab_5)
self.split2 = QSplitter(Qt.Vertical)
self.split2.addWidget(self.split1)
self.split2.addWidget(self.outputTabWidget)
self.horizontalLayout.addWidget(self.split2)
'''Status Bar'''
self.statusbar = QStatusBar(self)
self.aboutButton = QPushButton(self)
self.aboutButton.setFlat(True)
self.aboutButton.setIcon(Icons.anchor)
self.aboutButton.clicked.connect(self.about)
self.expButton = QPushButton(self)
self.expButton.setFlat(True)
self.expButton.setIcon(Icons.prj)
self.expButton.clicked.connect(self.exp)
self.cmdButton = QPushButton(self)
self.cmdButton.setFlat(True)
self.cmdButton.setIcon(Icons.console_view)
self.cmdButton.clicked.connect(self.cmd)
self.cmdButton.setShortcut('Ctrl+D')
self.imgButton = QPushButton(self)
self.imgButton.setFlat(True)
self.imgButton.setIcon(Icons.color_palette)
self.imgButton.clicked.connect(self.design)
self.imgButton.setShortcut('Ctrl+I')
self.findButton = QPushButton(self)
self.findButton.setFlat(True)
self.findButton.setIcon(Icons.find)
self.findButton.setShortcut("Ctrl+F")
self.findButton.clicked.connect(self.findBarShow)
'''
self.zoominButton = QPushButton(self)
self.zoominButton.setFlat(True)
self.zoominButton.setIcon(Icons.zoomplus)
self.zoominButton.clicked.connect(self.zoomin)
self.zoomoutButton = QPushButton(self)
self.zoomoutButton.setFlat(True)
self.zoomoutButton.setIcon(Icons.zoomminus)
self.zoomoutButton.clicked.connect(self.zoomout)
'''
'''Status Text,Line Text, Progress Bar and Stop Button'''
self.statusText = QLabel("Writable")
#self.statusText.setAlignment(Qt.AlignCenter)
self.statusText.setFixedWidth(200)
self.lineText = QLabel("")
self.lineText.setFixedWidth(50)
self.progressbar = QProgressBar()
self.progressbar.setMinimum(0)
self.progressbar.setMaximum(100)
self.stopButton = QPushButton(self)
self.stopButton.setFlat(True)
self.stopButton.setIcon(Icons.stop)
self.stopButton.clicked.connect(self.forceStop)
self.progressbar.hide()
self.stopButton.hide()
self.temp = False
self.progress = False
self.counter = 0
'''Adding all widgets to Status Bar'''
self.statusbar.addWidget(self.aboutButton)
self.statusbar.addWidget(self.expButton)
self.statusbar.addWidget(self.cmdButton)
self.statusbar.addWidget(self.imgButton)
self.statusbar.addWidget(self.findButton)
#self.statusbar.addWidget(QWidget(self))
#self.statusbar.addWidget(self.zoominButton)
#self.statusbar.addWidget(self.zoomoutButton)
self.statusbar.addWidget(self.statusText)
self.statusbar.addWidget(self.lineText)
self.statusbar.addWidget(self.progressbar)
self.statusbar.addWidget(self.stopButton)
#self.statusbar.setFixedHeight(18)
''''Initializing Coloring Style'''
self.initEditorStyle()
self.initStyleSheet()
'''Adding Cental Widget and Status Bar'''
self.setCentralWidget(self.centralwidget)
self.setStatusBar(self.statusbar)
self.textEdit.setReadOnly(True)
def initStyleSheet(self):
import stylesheet
self.setStyleSheet(stylesheet.mainstyl)
self.tabWidget.tabBar().setStyleSheet(stylesheet.stletabb)
self.explorerTabWidget.tabBar().setStyleSheet(stylesheet.stletabb)
self.outputTabWidget.tabBar().setStyleSheet(stylesheet.stletabb)
self.popWidget.setStyleSheet(stylesheet.popbg)
self.popWidget.hide()
''' This is for changing the palette/window colors to Theme '''
def initEditorStyle(self):
pass
#editStyle = config.readStyle()
#print editStyle
#pal = QPalette(self.explorerTabWidget.palette())
#print pal.color(QPalette.Base).name()
#print pal.color(QPalette.Window).name()
#pal.setColor(QPalette.Base,self.colorStyle.paper)
#pal.setColor(QPalette.Text,self.colorStyle.color)
#self.explorerTabWidget.setPalette(pal)
#self.outputTabWidget.setPalette(pal)
''' This is only for testing dont know if it works for builds '''
def changeStyleSheet(self):
''' Dynamically load the changed stylesheet.py and load the modules and change
the style at runtime saves countless deploys '''
import imp
foo = imp.load_source('stletabb', workDir+"/stylesheet.py")
#print foo.stletabb
#self.setStyleSheet(stylesheet.mainstyl)
self.tabWidget.tabBar().setStyleSheet(foo.stletabb)
self.popWidget.setStyleSheet(foo.popbg)
if(self.popWidget.isHidden()):
self.popWidget.showPopup()
def build_project(self):
#current_file = self.files[self.tabWidget.currentIndex()]
prj = self.treeWidget.getProject()
if(prj != None):
self.treeWidget.build(prj)
def run_project(self):
#current_file = self.files[self.tabWidget.currentIndex()]
prj = self.treeWidget.getProject()#current_file)
if(prj != None):
self.treeWidget.run(prj)
def forceStop(self):
self.ant.kill()
self.progressStop()
def kill(self):
self.deleteLater()
#-----------------------------------------------------------------------------------#
# Menu Actions Functions #
#-----------------------------------------------------------------------------------#
def run(self):
if(config.mode() == 0):
self.sq.run()
elif(config.mode() == 1):
self.adb.run()
elif(config.mode() == 2):
self.ios.run()
elif(config.mode() == 3):
self.c.run()
def setMode(self, action):
if(action.text() == "Squ"):
config.setMode(0)
self.toolBar.action_Build.setEnabled(False)
self.toolBar.action_Run.setEnabled(False)
elif(action.text() == "Emo"):
config.setMode(1)
self.toolBar.action_Build.setEnabled(True)
self.toolBar.action_Run.setEnabled(True)
elif(action.text() == "Android"):
config.setMode(2)
self.toolBar.action_Build.setEnabled(True)
self.toolBar.action_Run.setEnabled(True)
elif(action.text() == "ios"):
config.setMode(3)
self.toolBar.action_Build.setEnabled(False)
self.toolBar.action_Run.setEnabled(False)
def openCommand(self):
text, ok = QInputDialog.getText(self, 'Run Command', 'Command:')
cmd = str(text)
if ok and cmd != "":
import subprocess
subprocess.Popen(cmd)
def about(self):
form = DialogAbout(self)
def todo(self):
form = DialogTodo(self)
form.show()
def help(self):
QMessageBox.about(self,"Help","This is about all The Help that i can Give you now")
def full(self):
if not self.isFull:
self.setWindowState(Qt.WindowFullScreen)
self.isFull = True
else:
self.setWindowState(Qt.WindowMaximized)
self.isFull = False
def android(self):
form = DialogAndroid(self)
form.show()
def antt(self):
form = DialogAnt(self)
form.show()
def squirrel(self):
form = DialogSquirrel(self)
form.show()
def findBarShow(self):
if(self.findLayoutWidget.isHidden()):
self.findLayoutWidget.show()
else:
self.findLayoutWidget.hide()
def exp(self):
if(self.explorerTabWidget.isHidden()):
self.explorerTabWidget.show()
else:
self.explorerTabWidget.hide()
def cmd(self):
if(self.outputTabWidget.isHidden()):
self.outputTabWidget.show()
else:
self.outputTabWidget.hide()
def editor(self):
if(self.editorLayoutWidget.isHidden()):
self.editorLayoutWidget.show()
self.levelLayoutWidget.hide()
self.designerLayoutWidget.hide()
def design(self):
if(self.designerLayoutWidget.isHidden()):
self.designerLayoutWidget.show()
self.editorLayoutWidget.hide()
self.levelLayoutWidget.hide()
else:
self.designerLayoutWidget.hide()
self.editorLayoutWidget.show()
def level(self):
if(self.levelLayoutWidget.isHidden()):
self.levelLayoutWidget.show()
self.editorLayoutWidget.hide()
self.designerLayoutWidget.hide()
else:
self.levelLayoutWidget.hide()
self.editorLayoutWidget.show()
def closeDesigner(self,no):
pass
'''
if(no == self.tiler.closeIndex()):
if(self.tiler.isHidden()):
self.tiler.show()
else:
self.tiler.setCurrentIndex(1)
self.tiler.hide()
'''
'''The current Changed idx of outputTabWidget is passed to this a param'''
def closeConsole(self,no = 2):
if(no == 2):
if(self.outputTabWidget.isHidden()):
self.outputTabWidget.show()
else:
self.outputTabWidget.setCurrentIndex(1)
self.outputTabWidget.hide()
def popOutput(self):
if(self.outputTabWidget.isHidden()):
self.outputTabWidget.show()
self.outputTabWidget.setCurrentIndex(1)
def popError(self):
if(self.outputTabWidget.isHidden()):
self.outputTabWidget.show()
self.outputTabWidget.setCurrentIndex(0)
'''The current Changed idx of explorerTabWidget is passed to this a param'''
def closeExplorer(self,no = 2):
if(no == 2):
if(self.explorerTabWidget.isHidden()):
self.explorerTabWidget.show()
else:
self.explorerTabWidget.setCurrentIndex(0)
self.explorerTabWidget.hide()
elif(no == 1):
self.fileChanged(no)
''' This is to refresh the outline widget'''
def fileChanged(self,no):
if(self.explorerTabWidget.currentIndex() == 1):
edt = self.tabWidget.widget(self.tabWidget.currentIndex())
source = edt.text()
self.outlineWidget.parseText(source)
def statusSaving(self):
self.statusText.setText("Saving")
def statusParsing(self):
self.statusText.setText("Parsing")
def statusWriting(self):
self.statusText.setText("Writable")
def statusRunning(self):
self.statusText.setText("Running")
def statusStopping(self):
self.statusText.setText("Stopping")
def statusCommand(self):
self.statusText.setText("Command")
def statusBuilding(self):
self.statusText.setText("Building")
def statusInstalling(self):
self.statusText.setText("Installing")
def statusCleaning(self):
self.statusText.setText("Cleaning")
def statusCreating(self):
self.statusText.setText("Creating")
def progressStart(self):
self.progress == True
self.temp == True
if(self.progressbar.isHidden()):
self.progressbar.show()
if(self.stopButton.isHidden()):
self.stopButton.show()
self.progressbar.setValue(1)
def progressStop(self):
self.progress == False
self.temp == False
self.progressbar.setValue(100)
if not(self.progressbar.isHidden()):
self.progressbar.hide()
if not(self.stopButton.isHidden()):
self.stopButton.hide()
def progressUpdate(self):
if(self.progress):
if(self.temp):
self.counter += 1
self.progressbar.setValue(self.counter)
if(self.counter == 100):
self.temp = False
else:
self.counter -= 1
self.progressbar.setValue(self.counter)
if(self.counter == 0):
self.temp = True
#-----------------------------------------------------------------------------------#
# Editor Functions #
#-----------------------------------------------------------------------------------#
'''Search and Replace Functions'''
def findCurrentText(self):
edt = self.tabWidget.widget(self.tabWidget.currentIndex())
edt.findText(self.lineEdit.text(),self.regex.isChecked(),self.caseSensitive.isChecked(),self.wholeWord.isChecked(),self.backward.isChecked())
def replaceCurrentText(self):
edt = self.tabWidget.widget(self.tabWidget.currentIndex())
edt.replaceText(self.lineEdit_2.text())
def replaceFindText(self):
edt = self.tabWidget.widget(self.tabWidget.currentIndex())
edt.replaceText(self.lineEdit_2.text())
self.findCurrentText()
def replaceAllText(self):
edt = self.tabWidget.widget(self.tabWidget.currentIndex())
while(edt.findText(self.lineEdit.text(),self.regex.isChecked(),self.caseSensitive.isChecked(),self.wholeWord.isChecked(),self.backward.isChecked())):
edt.replaceText(self.lineEdit_2.text())
def errorLine(self,error):
index = self.tabWidget.currentIndex()
edt = self.tabWidget.widget(index)
'''To prevent File item double clicking'''
if(error.isFile() == False):
edt.setLine(error.line)
'''Font Functions'''
def zoomin(self):
pass
#for i in range(len(self.files)):
# self.tabWidget.widget(i).zoomin()
def zoomout(self):
pass
#for i in range(len(self.files)):
# self.tabWidget.widget(i).zoomout()
''' Must implement Lexer '''
def setLexer(self, action):
pass
#print action.text()
def setApi(self, action):
#print action.text()
for i in range(len(self.files)): #not QString
self.tabWidget.widget(i).setApi(str(action.text()))
def setFont(self,font):
config.setFontName(str(font.family()))
for i in range(len(self.files)):
self.tabWidget.widget(i).setNewFont(font)
def setFontSize(self,idx):
fontSize = idx+1
config.setFontSize(fontSize)
for i in range(len(self.files)):
self.tabWidget.widget(i).setFontSize()
def gotoLine(self,item):
edt = self.tabWidget.widget(self.tabWidget.currentIndex())
edt.setLine(item.line)
def updateLine(self,no,col):
self.lineText.setText(str(no)+" : "+str(col))
def setMargin(self):
mar = config.margin()
if(mar == 0):
config.setMargin(1)
for i in range(len(self.files)):
self.tabWidget.widget(i).setMargin(1)
else:
config.setMargin(0)
for i in range(len(self.files)):
self.tabWidget.widget(i).setMargin(0)
''' Toggle '''
def setIndent(self):
indent = config.indent()
if(indent == 0):
config.setIndent(1)
for i in range(len(self.files)):
self.tabWidget.widget(i).setIndent(1)
else:
config.setIndent(0)
for i in range(len(self.files)):
self.tabWidget.widget(i).setIndent(0)
''' Toggle '''
def setWhiteSpace(self):
white = config.whiteSpace()
if(white == 0):
config.setWhiteSpace(1)
for i in range(len(self.files)):
self.tabWidget.widget(i).setWhitespaceVisibility(True)
else:
config.setWhiteSpace(0)
for i in range(len(self.files)):
self.tabWidget.widget(i).setWhitespaceVisibility(False)
''' Toggle '''
def setEndLine(self):
for i in range(len(self.files)):
edt = self.tabWidget.widget(i)
edt.setEolVisibility(not edt.eolVisibility())
def setEncoding(self, action):
if(action.text() == "Ascii"):
config.setAscii()
for i in range(len(self.files)):
self.tabWidget.widget(i).setUtf8(False)
elif(action.text() == "Unicode"):
config.setUnicode()
for i in range(len(self.files)):
self.tabWidget.widget(i).setUtf8(True)
def setThreshold(self,val):
config.setThresh(val)
for i in range(len(self.files)):
#print i
self.tabWidget.widget(i).setThreshold(val)
def setTabWidth(self,val):
config.setTabWidth(val)
for i in range(len(self.files)):
#print i
self.tabWidget.widget(i).setTabWidth(val)
'''style Functions'''
#-----------------------------------------------------------------------------------#
# Command Functions #
#-----------------------------------------------------------------------------------#
def getFile(self):
self.browsedialog = DialogBrowse(self)
self.browsedialog.tree.itemDoubleClicked.connect(self.getName)
self.browsedialog.show()
def getName(self,item):
if(item.isFile()):
self.browsedialog.accept()
fname = item.getPath()
if not (fname == ""):
index = self.combo2.currentIndex()
text = str(self.combo2.itemText(index))+" "+fname
self.combo2.setItemText(index,text)
self.paramList.pop(index)
self.paramList.insert(index,text)
config.setParam(self.paramList)
def addCmd(self,index):
text, ok = QInputDialog.getText(self, 'Add Command', 'Command:')
if(ok):
if(str(text) != ''):
cmd = str(text).upper()
self.cmdList.append(cmd)
#print self.cmdList
self.combo.addItem(cmd)
config.setCmd(self.cmdList)
config.setParam(self.paramList)
def delCmd(self):
index = self.combo.currentIndex()
self.combo.removeItem(index)
self.cmdList.pop(index)
#print self.cmdList
config.setCmd(self.cmdList)
def addParam(self,index):
text, ok = QInputDialog.getText(self, 'Add Parameters', 'Params:')
if(ok):
if(str(text) != ''):
param = str(text)
self.paramList.append(param)
self.combo2.addItem(param)
config.setParam(self.paramList)
def delParam(self):
index = self.combo2.currentIndex()
self.combo2.removeItem(index)
self.paramList.pop(index)
config.setParam(self.paramList)
def checkHasValue(self,list):
if(list != None and len(list) != 0):
return True
else:
return False
class Entity(QWidget):
def __init__(self, base_image, size, hp=100, pos=(0, 0), parent=None):
super().__init__(parent)
self._base_label = QLabel(self)
self._base_image = base_image
self._size = size
self._decor_label = None
self._decor_pixmap = None
self._hp_max = hp
self.__pixmap = None
""":type: PyQt4.QtGui.QPixmap"""
self.__cord_x = pos[0]
self.__cord_y = pos[1]
self.__angle = 0
self.__hp_bar = QProgressBar(self)
self.__hp_bar.setMaximum(self._hp_max)
self.__hp_bar.setValue(self._hp_max)
self.__hp_bar.setTextVisible(False)
self.__hp_bar.setMaximumSize(size[0], 5)
self.setAlignment(Qt.AlignCenter)
self.updatePixmap()
if _debugging:
self.setStyleSheet("border: 1px solid black")
@property
def health(self):
return self.__hp_bar.value()
@health.setter
def health(self, hp):
if hp > self._hp_max:
hp = self._hp_max
elif hp < 0:
hp = 0
self.__hp_bar.setValue(hp)
@property
def angle(self):
return self.__angle
@angle.setter
def angle(self, angle):
self.__angle = angle
self.updatePixmap()
@property
def cord_x(self):
return self.__cord_x
@cord_x.setter
def cord_x(self, cord):
self.__cord_x = cord
self.move(self.cord_x, self.cord_y)
@property
def cord_y(self):
return self.__cord_y
@cord_y.setter
def cord_y(self, cord):
self.__cord_y = cord
self.move(self.cord_x, self.cord_y)
def hide_hp_bar(self, bool=False):
if bool:
self.__hp_bar.hide()
else:
self.__hp_bar.show()
def add_decoration(self, path):
if path is None:
self._decor_label.deleteLater()
self._decor_label = None
else:
self._decor_label = QLabel(self)
self._decor_pixmap = QPixmap(path)
# self._decor_pixmap = self._decor_pixmap.scaled(self._size[0], self._size[1])
self._decor_pixmap = self._decor_pixmap.transformed(QTransform().rotate(self.angle))
self._decor_label.setPixmap(self._decor_pixmap)
self._decor_label.setAlignment(Qt.AlignCenter)
self._decor_label.show()
def updatePixmap(self):
path = get_asset_path(self._base_image)
self.__pixmap = QPixmap(path)
self.__pixmap = self.__pixmap.scaled(self._size[0], self._size[1])
self.__pixmap = self.__pixmap.transformed(QTransform().rotate(self.angle))
self._base_label.setPixmap(self.__pixmap)
self._base_label.show()
# self.setFixedSize(self.__pixmap.width(), self.__pixmap.height())
def setFixedSize(self, x, y):
super().setFixedSize(x, y)
self._base_label.setFixedSize(x, y)
def setAlignment(self, alignment):
self._base_label.setAlignment(alignment)
def run(self):
"""Run method that performs all the real work"""
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
gradle_command = self.get_gradle_dir()
dc_directory = self.dlg.lineEdit.text()
print dc_directory
if dc_directory == '':
self.iface.messageBar().pushMessage("Error", "Please provide the directory of the Digital Connector", level=QgsMessageBar.CRITICAL)
else:
dc_recipe = self.track_recipe_choice()
to_save = self.select_output_name()
# Update DC and QGIS repo
if self.dlg.checkBox_2.isChecked():
git_path = None
if platform.system() == 'Windows':
# Look in both Program Files and Program Files x86
for i in os.listdir('C:\\Program Files'):
if 'Git' in i:
git_path = 'C:\\Program Files\\' + i + '\\bin'
# No single quotes allowed in the string on Windows...
output = sp.call('{0}\\git pull'.format(git_path), cwd=dc_directory)
else:
pass
for j in os.listdir('C:\\Program Files (x86)'):
if 'Git' in j:
git_path = 'C:\\Program Files (x86)\\' + j + '\\bin'
output = sp.call('{0}\\git pull'.format(git_path), cwd=dc_directory)
else:
pass
# If all fails ask user
if git_path == None:
git_path = QFileDialog.getExistingDirectory(
self.dlg,
"Select git path",
expanduser("~"),
QFileDialog.ShowDirsOnly
)
output = sp.call('{0}\\git pull'.format(git_path), cwd=dc_directory)
# git pull for Mac OSX
elif platform.system() == 'Darwin':
for i in os.listdir('/usr/local/Cellar/'):
if 'git' in i:
git_path = '/usr/local/Cellar/' + i + '/' + os.listdir('/usr/local/Cellar/'+ i)[0] + \
'/' + 'bin/git'
args = ['{0} pull'.format(git_path)]
output = sp.Popen(args, stdout=sp.PIPE, cwd=dc_directory, shell=True)
else:
pass
if git_path == None:
git_path = QFileDialog.getExistingDirectory(
self.dlg,
"Select git path",
expanduser("~"),
QFileDialog.ShowDirsOnly
)
args = ['{0} pull'.format(git_path)]
output = sp.Popen(args, stdout=sp.PIPE, cwd=dc_directory, shell=True)
else:
print 'currently the plugin only supports Mac and Windows'
# check if the path corresponds to the examples folder or not.
# This is necessary due to the absolute paths of subprocess
chars = set("\/")
if any((c in chars) for c in dc_recipe):
pass
else:
dc_recipe = '{0}/src/main/resources/executions/examples/{1}'.format(dc_directory,dc_recipe,to_save)
# Check for -Pclear=True
if self.dlg.checkBox.isChecked():
p_clear = 'true'
else:
p_clear= 'false'
# TODO need to add more error messages
if not to_save:
self.iface.messageBar().pushMessage("Error", "Please choose a name for the output file", level=QgsMessageBar.CRITICAL)
else:
if platform.system() == 'Windows':
if not gradle_command in os.environ['PATH']:
os.environ['PATH'] += ';' + gradle_command
else:
pass
# No single quotes allowed in the string on Windows...
output = sp.call('{0} runExport -Precipe="{2}" -Poutput="{3}" -Pclear="{4}"'.format(gradle_command + '\\gradle.bat',
dc_directory,dc_recipe,to_save, p_clear),
cwd=dc_directory)
# Adding the resulting layer in the QGIS Layers Panel
vlayer = QgsVectorLayer(to_save,to_save.split("/")[-1],"ogr")
QgsMapLayerRegistry.instance().addMapLayer(vlayer)
else:
args = ["{0} runExport -Precipe='{2}' -Poutput='{3}' -Pclear='{4}'".format(gradle_command,dc_directory,
dc_recipe,to_save, p_clear)]
output = sp.Popen(args,stdout=sp.PIPE, cwd=dc_directory, shell=True)
for log in iter(output.stdout.readline, b''):
sys.stdout.write(str(log) + '\n')
progressbar = QProgressBar()
progressbar.setMinimum(0)
progressbar.setMaximum(0)
progressbar.setValue(0)
progressbar.setWindowTitle("Running gradle task...")
progressbar.show()
# Adding the resulting layer in the QGIS Layers Panel
vlayer = QgsVectorLayer(to_save,to_save.split("/")[-1],"ogr")
QgsMapLayerRegistry.instance().addMapLayer(vlayer)
class MainWindow(KXmlGuiWindow):
"Class which displays the main Danbooru Client window."
def __init__(self, *args):
"Initialize a new main window."
super(MainWindow, self).__init__(*args)
self.cache = KPixmapCache("danbooru")
self.preferences = preferences.Preferences()
self.api = None
self.__ratings = None
self.__step = 0
self.url_list = self.preferences.boards_list
self.max_retrieve = self.preferences.thumbnail_no
self.statusbar = self.statusBar()
self.progress = QProgressBar()
self.thumbnailarea = None
self.tag_dock = None
self.pool_dock = None
self.first_fetch_widget = None
self.progress.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
# FIXME: Hackish, but how to make it small otherwise?
self.progress.setMinimumSize(100, 1)
self.statusbar.addPermanentWidget(self.progress)
self.progress.hide()
self.setup_welcome_widget()
self.setup_actions()
def reload_config(self):
"""Reload configuration after a change"""
urls = self.preferences.boards_list
if self.first_fetch_widget is not None:
self.first_fetch_widget.setup_urls(urls)
if self.thumbnailarea is not None:
max_thumbnail = self.preferences.thumbnail_no
max_rating = self.preferences.max_allowed_rating
self.thumbnailarea.fetchwidget.limit = max_thumbnail
self.thumbnailarea.fetchwidget.rating = max_rating
self.thumbnailarea.fetchwidget.update_values()
self.thumbnailarea.connectwidget.setup_urls(urls)
self.url_list = self.preferences.boards_list
self.max_retrieve = self.preferences.thumbnail_no
def setup_welcome_widget(self):
"""Load the welcome widget at startup."""
widget = QWidget()
layout = QVBoxLayout()
welcome = QLabel(parent=self)
pix = QPixmap(KStandardDirs.locate("appdata","logo.png"))
welcome.setPixmap(pix)
welcome.setAlignment(Qt.AlignCenter)
self.first_fetch_widget = connectwidget.ConnectWidget(
self.preferences.boards_list, self)
self.statusbar.addPermanentWidget(self.first_fetch_widget, 300)
self.first_fetch_widget.connectionEstablished.connect(
self.handle_connection)
self.first_fetch_widget.rejected.connect(
self.first_fetch_widget.hide)
self.first_fetch_widget.hide()
self.first_fetch_widget.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
layout.addWidget(self.first_fetch_widget)
layout.addWidget(welcome)
widget.setLayout(layout)
self.setCentralWidget(widget)
def setup_tooltips(self):
"""Set tooltips for the actions."""
self.connect_action.setToolTip(i18n("Connect to a Danbooru board"))
self.fetch_action.setToolTip(
i18n("Fetch thumbnails from a Danbooru board")
)
self.batch_download_action.setToolTip(i18n("Batch download images"))
def create_actions(self):
"""Create actions for the main window."""
self.connect_action = KAction(KIcon("document-open-remote"),
i18n("Connect"), self)
self.fetch_action = KAction(KIcon("download"), i18n("Download"),
self)
self.clean_action = KAction(KIcon("trash-empty"),
i18n("Clear thumbnail cache"),
self)
self.batch_download_action = KAction(KIcon("download"),
i18n("Batch download"), self)
self.pool_toggle_action = KToggleAction(KIcon("image-x-generic"),
i18n("Pools"), self)
self.tag_display_action = KDualAction(i18n("Show tags"),
i18n("Hide tags"),
self)
self.tag_display_action.setIconForStates(KIcon("image-x-generic"))
self.tag_display_action.setEnabled(False)
# Shortcuts
connect_default = KAction.ShortcutTypes(KAction.DefaultShortcut)
connect_active = KAction.ShortcutTypes(KAction.ActiveShortcut)
self.connect_action.setShortcut(KStandardShortcut.open())
self.fetch_action.setShortcut(KStandardShortcut.find())
self.fetch_action.setEnabled(False)
self.batch_download_action.setEnabled(False)
self.pool_toggle_action.setEnabled(False)
def setup_action_collection(self):
"""Set up the action collection by adding the actions."""
action_collection = self.actionCollection()
# Addition to the action collection
action_collection.addAction("connect", self.connect_action)
action_collection.addAction("fetch", self.fetch_action)
action_collection.addAction("clean", self.clean_action)
action_collection.addAction("batchDownload", self.batch_download_action)
action_collection.addAction("poolDownload", self.pool_toggle_action)
action_collection.addAction("tagDisplay", self.tag_display_action)
KStandardAction.quit (self.close, action_collection)
KStandardAction.preferences(self.show_preferences,
action_collection)
action_collection.removeAction(
action_collection.action("help_contents"))
action_collection.actionHovered.connect(self.setup_action_tooltip)
def setup_actions(self):
"""Set up the relevant actions, tooltips, and load the RC file."""
self.create_actions()
self.setup_tooltips()
self.setup_action_collection()
# Connect signals
self.connect_action.triggered.connect(self.connect)
self.fetch_action.triggered.connect(self.get_posts)
self.clean_action.triggered.connect(self.clean_cache)
self.batch_download_action.triggered.connect(self.batch_download)
self.pool_toggle_action.toggled.connect(self.pool_toggle)
self.tag_display_action.activeChanged.connect(self.tag_display)
window_options = self.StandardWindowOption(self.ToolBar| self.Keys |
self.Create | self.Save |
self.StatusBar)
setupGUI_args = [
QSize(500, 400), self.StandardWindowOption(window_options)
]
#Check first in standard locations for danbooruui.rc
rc_file = KStandardDirs.locate("appdata", "danbooruui.rc")
if rc_file.isEmpty():
setupGUI_args.append(os.path.join(sys.path [0],
"danbooruui.rc"))
else:
setupGUI_args.append(rc_file)
self.setupGUI(*setupGUI_args)
def setup_action_tooltip(self, action):
"Show statusbar help when actions are hovered."
if action.isEnabled():
self.statusBar().showMessage(action.toolTip(), 2000)
def setup_connections(self):
"""Set up connections for post and tag retrieval."""
if self.api is None:
return
self.api.postRetrieved.connect(self.update_progress)
self.api.postDownloadFinished.connect(self.download_finished)
self.api.tagRetrieved.connect(self.tag_dock.widget().add_tags)
self.tag_dock.widget().itemDoubleClicked.connect(
self.fetch_tagged_items)
def show_preferences(self):
"Show the preferences dialog."
if KConfigDialog.showDialog("Preferences dialog"):
return
else:
dialog = preferences.PreferencesDialog(self, "Preferences dialog",
self.preferences)
dialog.show()
dialog.settingsChanged.connect(self.reload_config)
def connect(self, ok):
"Connect to a Danbooru board."
if self.thumbnailarea is None:
self.first_fetch_widget.show()
else:
self.thumbnailarea.connectwidget.show()
def restore(self):
self.statusbar.removeWidget(self.connect_widget)
def handle_connection(self, connection):
self.api = None
self.api = connection
self.api.cache = self.cache
if self.pool_dock is not None:
self.pool_dock.hide()
self.pool_dock.widget().clear()
self.pool_toggle_action.setChecked(False)
if self.thumbnailarea is not None:
#TODO: Investigate usability
self.clear(clear_pool=True)
self.thumbnailarea.clear()
self.thumbnailarea.api_data = self.api
self.setup_connections()
else:
self.first_fetch_widget.connectionEstablished.disconnect()
self.first_fetch_widget.rejected.disconnect()
self.statusbar.removeWidget(self.first_fetch_widget)
self.setup_area()
self.api.cache = self.cache
self.statusBar().showMessage(i18n("Connected to %s" % self.api.url),
3000)
self.fetch_action.setEnabled(True)
# Set up pool widget
pool_widget = poolwidget.DanbooruPoolWidget(self.api)
self.pool_dock = QDockWidget("Pools", self)
self.pool_dock.setObjectName("PoolDock")
self.pool_dock.setAllowedAreas(Qt.BottomDockWidgetArea)
self.pool_dock.setWidget(pool_widget)
#self.pool_dock.setFeatures(QDockWidget.NoDockWidgetFeatures)
self.addDockWidget(Qt.BottomDockWidgetArea, self.pool_dock)
self.pool_dock.widget().poolDownloadRequested.connect(
self.pool_prepare)
self.pool_dock.hide()
self.pool_toggle_action.setEnabled(True)
self.clear() # Needed to show properly the stuff after connecting
self.api.get_post_list(tags="", limit=self.thumbnailarea.post_limit,
rating=self.preferences.max_allowed_rating,
blacklist=list(self.preferences.tag_blacklist))
self.api.get_tag_list(name="",blacklist=list(self.preferences.tag_blacklist),
limit=20)
def get_posts(self, ok):
"Get posts from the connected Danbooru board."
if not self.api:
return
self.thumbnailarea.fetchwidget.show()
def handle_fetching(self, tags, max_rating, limit):
"""Slot connected to the dataSent signal of the fetch widget.
The widgets are set up if they don't exist, and the API is queried
to do the actual downloading of tags and
"""
self.clear()
self.thumbnailarea.fetchwidget.hide()
if self.tag_dock is not None:
self.tag_dock.widget().clear()
self.thumbnailarea.post_limit = limit
blacklist= list(self.preferences.tag_blacklist)
self.api.get_post_list(tags=tags, limit=limit,
rating=max_rating,
blacklist=blacklist)
tags = [item for item in tags if item]
if not tags:
# No related tags, fetch the most recent 20
tags = ""
self.api.get_tag_list(name=tags,blacklist=blacklist,
limit=20)
else:
self.api.get_related_tags(tags=tags, blacklist=blacklist)
def fetch_tagged_items(self, item):
"""Fetch items found in the tag list widget."""
tag_name = unicode(item.text())
self.clear()
blacklist = self.preferences.tag_blacklist
limit = self.preferences.thumbnail_no
rating = self.preferences.max_allowed_rating
self.api.get_post_list(page=1, tags=[tag_name],
blacklist=blacklist,
limit=limit,
rating=rating)
self.api.get_related_tags(tags=[tag_name], blacklist=blacklist)
def pool_toggle(self, checked):
"Toggle the presence/absence of the pool dock."
if not self.api:
return
if not checked:
self.pool_dock.hide()
else:
self.pool_dock.show()
def pool_prepare(self, pool_id):
"""Prepare the central area for pool image loading."""
if self.thumbnailarea is None:
self.setup_area()
else:
self.clear(clear_pool=False)
self.api.get_pool(pool_id, blacklist=self.preferences.tag_blacklist,
rating=self.preferences.max_allowed_rating)
def batch_download(self, ok):
"Download images in batch."
selected_items = self.thumbnailarea.selected_images()
if not selected_items:
return
start_url = KUrl("kfiledialog:///danbooru")
caption = i18n("Select a directory to save the images to")
directory = KFileDialog.getExistingDirectoryUrl(start_url, self,
caption)
if directory.isEmpty():
return
for item in selected_items:
file_url = item.url_label.url()
tags = item.data.tags
# Make a local copy to append paths as addPath works in-place
destination = KUrl(directory)
file_name = KUrl(file_url).fileName()
destination.addPath(file_name)
job = KIO.file_copy(KUrl(file_url), destination, -1)
job.setProperty("tags", QVariant(tags))
job.result.connect(self.batch_download_slot)
def setup_area(self):
"Set up the central widget to display thumbnails."
self.thumbnailarea = thumbnailarea.DanbooruTabWidget(self.api,
self.preferences, self.preferences.thumbnail_no, self)
self.setCentralWidget(self.thumbnailarea)
self.thumbnailarea.connectwidget.connectionEstablished.connect(
self.handle_connection, type=Qt.UniqueConnection)
self.thumbnailarea.connectwidget.rejected.connect(
self.thumbnailarea.connectwidget.hide, type=Qt.UniqueConnection)
self.thumbnailarea.fetchwidget.dataSent.connect(
self.handle_fetching, type=Qt.UniqueConnection)
self.thumbnailarea.fetchwidget.rejected.connect(
self.thumbnailarea.fetchwidget.hide, type=Qt.UniqueConnection)
# Set up tag widget
blacklist = self.preferences.tag_blacklist
tag_widget = tagwidget.DanbooruTagWidget(blacklist, self)
self.tag_display_action.setActive(True)
self.tag_display_action.setEnabled(True)
self.tag_dock = QDockWidget("Similar tags", self)
self.tag_dock.setObjectName("TagDock")
self.tag_dock.setAllowedAreas(Qt.RightDockWidgetArea)
self.tag_dock.setWidget(tag_widget)
#self.tag_dock.setFeatures(QDockWidget.NoDockWidgetFeatures)
self.addDockWidget(Qt.RightDockWidgetArea, self.tag_dock)
self.tag_dock.hide()
# Container signal-slot connections
self.setup_connections()
def download_finished(self):
"""Slot called when all the data has been completed. Clears the progress
bar and resets it to 0."""
if not self.batch_download_action.isEnabled():
self.batch_download_action.setEnabled(True)
self.__step = 0
self.progress.hide()
def update_progress(self):
"Update the progress bar."
if not self.progress.isVisible():
self.progress.show()
self.__step += 1
self.progress.setValue(self.__step)
def clear(self, clear_pool=True):
"Clear the central widget."
if self.thumbnailarea is None:
return
self.thumbnailarea.clear()
self.tag_dock.widget().clear()
if clear_pool:
self.pool_dock.widget().clear()
self.batch_download_action.setEnabled(False)
def clean_cache(self):
"Purge the thumbnail cache."
self.cache.discard()
self.statusBar().showMessage(i18n("Thumbnail cache cleared."))
def batch_download_slot(self, job):
"""Slot called when doing batch download, for each file retrieved.
If Nepomuk tagging is enabled, each file is tagged using the item's
respective tags.
"""
if job.error():
job.ui().showErrorMessage()
else:
if self.preferences.nepomuk_enabled:
tags = job.property("tags").toPyObject()
#danbooru2nepomuk.tag_danbooru_item(job.destUrl().path(),
# tags)
def tag_display(self, state):
"""Display or hide the tag dock."""
if self.tag_dock is None:
self.tag_display_action.setActive(False)
return
if state:
self.tag_dock.show()
else:
self.tag_dock.hide()
class LabelAssistDialog(QDialog):
"""
A simple UI for showing bookmarks and navigating to them.
FIXME: For now, this window is tied to a particular lane.
If your project has more than one lane, then each one
will have it's own bookmark window, which is kinda dumb.
"""
def __init__(self, parent, topLevelOperatorView):
super(LabelAssistDialog, self).__init__(parent)
# Create thread router to populate table on main thread
self.threadRouter = ThreadRouter(self)
# Set object classification operator view
self.topLevelOperatorView = topLevelOperatorView
self.setWindowTitle("Label Assist")
self.setMinimumWidth(500)
self.setMinimumHeight(700)
layout = QGridLayout()
layout.setContentsMargins(10, 10, 10, 10)
# Show variable importance table
rows = 0
columns = 4
self.table = QTableWidget(rows, columns)
self.table.setHorizontalHeaderLabels(['Frame', 'Max Area', 'Min Area', 'Labels'])
self.table.verticalHeader().setVisible(False)
# Select full row on-click and call capture double click
self.table.setSelectionBehavior(QTableView.SelectRows);
self.table.doubleClicked.connect(self._captureDoubleClick)
layout.addWidget(self.table, 1, 0, 3, 2)
# Create progress bar
self.progressBar = QProgressBar()
self.progressBar.setMinimum(0)
self.progressBar.setMaximum(0)
self.progressBar.hide()
layout.addWidget(self.progressBar, 4, 0, 1, 2)
# Create button to populate table
self.computeButton = QPushButton('Compute object info')
self.computeButton.clicked.connect(self._triggerTableUpdate)
layout.addWidget(self.computeButton, 5, 0)
# Create close button
closeButton = QPushButton('Close')
closeButton.clicked.connect(self.close)
layout.addWidget(closeButton, 5, 1)
# Set dialog layout
self.setLayout(layout)
def _triggerTableUpdate(self):
# Check that object area is included in selected features
featureNames = self.topLevelOperatorView.SelectedFeatures.value
if 'Standard Object Features' not in featureNames or 'Count' not in featureNames['Standard Object Features']:
box = QMessageBox(QMessageBox.Warning,
'Warning',
'Object area is not a selected feature. Please select this feature on: \"Standard Object Features > Shape > Size in pixels\"',
QMessageBox.NoButton,
self)
box.show()
return
# Clear table
self.table.clearContents()
self.table.setRowCount(0)
self.table.setSortingEnabled(False)
self.progressBar.show()
self.computeButton.setEnabled(False)
def compute_features_for_frame(tIndex, t, features):
# Compute features and labels (called in parallel from request pool)
roi = [slice(None) for i in range(len(self.topLevelOperatorView.LabelImages.meta.shape))]
roi[tIndex] = slice(t, t+1)
roi = tuple(roi)
frame = self.topLevelOperatorView.SegmentationImages(roi).wait()
frame = frame.squeeze().astype(numpy.uint32, copy=False)
# Dirty trick: We don't care what we're passing here for the 'image' parameter,
# but vigra insists that we pass *something*, so we'll cast the label image as float32.
features[t] = vigra.analysis.extractRegionFeatures(frame.view(numpy.float32),
frame,
['Count'],
ignoreLabel=0)
tIndex = self.topLevelOperatorView.SegmentationImages.meta.axistags.index('t')
tMax = self.topLevelOperatorView.SegmentationImages.meta.shape[tIndex]
features = {}
labels = {}
def compute_all_features():
# Compute features in parallel
pool = RequestPool()
for t in range(tMax):
pool.add( Request( partial(compute_features_for_frame, tIndex, t, features) ) )
pool.wait()
# Compute labels
labels = self.topLevelOperatorView.LabelInputs([]).wait()
req = Request(compute_all_features)
req.notify_finished( partial(self._populateTable, features, labels) )
req.submit()
@threadRouted
def _populateTable(self, features, labels, *args):
self.progressBar.hide()
self.computeButton.setEnabled(True)
for time, feature in features.iteritems():
# Insert row
rowNum = self.table.rowCount()
self.table.insertRow(self.table.rowCount())
# Get max and min object areas
areas = feature['Count']#objectFeatures['Standard Object Features']['Count']
maxObjArea = numpy.max(areas[numpy.nonzero(areas)])
minObjArea = numpy.min(areas[numpy.nonzero(areas)])
# Get number of labeled objects
labelNum = numpy.count_nonzero(labels[time])
# Load fram number
item = QTableWidgetItem(str(time))
item.setFlags( Qt.ItemIsSelectable | Qt.ItemIsEnabled )
self.table.setItem(rowNum, 0, item)
# Load max object areas
item = QTableWidgetItemWithFloatSorting(str("{: .02f}".format(maxObjArea)))
item.setFlags( Qt.ItemIsSelectable | Qt.ItemIsEnabled )
self.table.setItem(rowNum, 1, item)
# Load min object areas
item = QTableWidgetItemWithFloatSorting(str("{: .02f}".format(minObjArea)))
item.setFlags( Qt.ItemIsSelectable | Qt.ItemIsEnabled )
self.table.setItem(rowNum, 2, item)
# Load label numbers
item = QTableWidgetItemWithFloatSorting(str("{: .01f}".format(labelNum)))
item.setFlags( Qt.ItemIsSelectable | Qt.ItemIsEnabled )
self.table.setItem(rowNum, 3, item)
# Resize column size to fit dialog size
self.table.horizontalHeader().setResizeMode(QHeaderView.Stretch)
# Sort by max object area
self.table.setSortingEnabled(True)
self.table.sortByColumn(1)
def _captureDoubleClick(self):
# Navigate to selected frame
index = self.table.selectedIndexes()[0]
frameStr = self.table.model().data(index).toString()
if frameStr:
frameNum = int(frameStr)
self.parent().editor.posModel.time = frameNum
class WidgetFFmpegConcatAudio(QDialog):
def __init__(self, cheminVideoEntre, cheminFFmpeg=None):
QDialog.__init__(self)
# === Paramètres généraux ===#
# Uniquement pour Linux et MacOSX
if os.name in ["posix", "mac"] or not cheminFFmpeg:
self.cheminFFmpeg = u"ffmpeg"
# Uniquement pour windows
elif os.name == "nt" and cheminFFmpeg:
self.cheminFFmpeg = unicode(cheminFFmpeg)
# chemin(s) des vidéos chargées
self.cheminVideoEntre = cheminVideoEntre
self.fichiers = [os.path.basename(parc) for parc in self.cheminVideoEntre]
self.appliquer()
@pyqtSignature("")
def appliquer(self):
self.labelAttente = QLabel()
self.labelAttente.setText(
_(
u"<p><b>Encodage des fichiers audio en WAV</b></p><p>Attendez la fin du calcul s'il vous plaît (soyez patient !) ... traitement des fichiers: </p><p><b>%s</b></p>"
% "<br>".join(self.cheminVideoEntre)
)
)
self.bout_annuler = QPushButton(_(u"Annuler"))
self.progress = QProgressBar()
self.progress.setMaximum(100)
self.progress.setValue(0)
vbox = QVBoxLayout()
vbox.addWidget(self.labelAttente)
hbox = QHBoxLayout()
hbox.addWidget(self.progress)
hbox.addWidget(self.bout_annuler)
vbox.addLayout(hbox)
self.setLayout(vbox)
self.connect(self.bout_annuler, SIGNAL("clicked()"), SLOT("close()"))
self.th = FfmpegConcatThread(self.cheminVideoEntre, self.cheminFFmpeg)
# Connections pour l'appel et l'application du pourcentage dans la barre
# ... essai de récup du fichier chargé ... pour eventuellement pouvoir
# afficher le fichiers en cours dans la barre (au dessus de la barre
# elle même --> mais pas réussi à importer fichier_1 pour pouvoir
# l'afficher à la place de self.fichiers dans self.progress
self.th.connect(self.th, SIGNAL("increment(int)"), self.affichPourcent)
self.th.connect(self.th, SIGNAL("travail_avec_fichier"), self.fichierDeTravail)
self.progress.connect(self.progress, SIGNAL("canceled()"), self.th, SLOT("cancel()"))
self.progress.show()
self.th.start()
# On ajoute un parametre à la méthode
def affichPourcent(self, pourcent):
self.progress.setValue(pourcent)
QApplication.processEvents()
# Quand la progression arrive à 100%, la fenêtre
# contenant la QProgressBar se ferme
if pourcent == 100:
self.close()
# De même, on ajoute un parametre à la méthode
def fichierDeTravail(self, fichier_1):
debug("Fichier chargé: %s" % fichier_1)
class Form(QMainWindow, Ui_MainWindow):
"""IT Query Main Window."""
def __init__(self, initIds, initErrIds, parent=None):
"""Setup main window and populate with data(if given)."""
super(Form, self).__init__(parent)
self.setupUi(self)
self.setWindowTitle("IT Query {0}".format(__version__))
self.selectedIds = initIds
self.errorIds = initErrIds
LOG_LEVEL = logging.INFO
currTime = time.localtime()
runDate = time.strftime("%Y-%m-%d", currTime)
self.dbPath = DB.Db.Info.Path
LOG_FNAME = "{0}\{1}-{2}.{3}".format(self.dbPath, "itquery",
runDate, "txt")
if LOG_LEVEL == logging.INFO:
LOG_FORMAT = "%(asctime)s\t%(message)s"
else:
LOG_FORMAT = ("%(asctime)s - %(levelname)s - %(funcName)s "
" - %(message)s")
self.logger = logging.getLogger("itquery")
self.logger.setLevel(LOG_LEVEL)
self.handler = logging.FileHandler(LOG_FNAME)
formatter = logging.Formatter(LOG_FORMAT)
self.handler.setFormatter(formatter)
self.logger.addHandler(self.handler)
for action, slot in ((self.updateButton, self.updateSelection),
(self.bionumericsButton, self.bnSelectFields),
(self.itemTrackerButton, self.itSelectFields)):
action.clicked.connect(slot)
for action, slot in ((self.actionCollapseAll, self.collapseAll),
(self.actionExpandAll, self.expandAll),
(self.actionCollapseItem, self.collapseItem),
(self.actionCherryPicking, self.cherryPicking),
(self.actionExpandItem, self.expandItem),
(self.actionSelectAll, self.selectAll),
(self.actionSelectDNA, self.selectDNA),
(self.actionSelectFrozenStock, self.selectFrozenStock),
(self.actionSelectInvert, self.selectInvert),
(self.actionSelectNone, self.selectNone),
(self.actionGetAllSelected, self.getAllSelected),
(self.actionRefresh, self.refresh),
(self.actionAbout, self.about),
(self.actionViewTree, self.viewTree),
(self.actionClearLog, self.clearLog),
(self.actionLegend, self.legend),
(self.actionExportTraceList, self.exportTraceList),
(self.actionExportDNAList, self.exportDNAList),
(self.actionClose, self.close)):
action.triggered.connect(slot)
self.treeWidget.itemSelectionChanged.connect(self.updateInfo)
self.viewMenu.addAction(self.logDockWidget.toggleViewAction())
icon = QIcon(":/text-x-log.png")
self.logDockWidget.toggleViewAction().setIcon(icon)
self.actionSelectInBionumerics.toggled.connect(self.selectInBionumerics)
self.userComboBox.currentIndexChanged.connect(self.userChanged)
self.statusComboBox.currentIndexChanged.connect(self.statusChanged)
self.treeActions = QActionGroup(self)
self.treeActions.addAction(self.actionExpandItem)
self.treeActions.addAction(self.actionCollapseItem)
self.treeActions.addAction(self.actionExpandAll)
self.treeActions.addAction(self.actionCollapseAll)
self.selectActions = QActionGroup(self)
self.selectActions.addAction(self.actionSelectAll)
self.selectActions.addAction(self.actionSelectNone)
self.selectActions.addAction(self.actionSelectInvert)
self.selectActions.addAction(self.actionSelectDNA)
self.selectActions.addAction(self.actionSelectFrozenStock)
self.exportActions = QActionGroup(self)
self.exportActions.addAction(self.actionExportDNAList)
self.exportActions.addAction(self.actionExportTraceList)
self.statusbar.setSizeGripEnabled(True)
# user label at the right end of status bar
# db = lims.DATABASE
db = "No information"
dbLabel = QLabel("Database: <b>{0}</b>".format(db))
self.statusbar.addPermanentWidget(dbLabel)
user = os.environ.get("USERNAME") or "Demo user"
label = QLabel("Logged in as: <b>{0}</b>".format(user))
self.statusbar.addPermanentWidget(label)
# restore main window state
settings = QSettings()
size = settings.value("MainWindow/Size",
QVariant(QSize(600, 500))).toSize()
self.resize(size)
position = settings.value("MainWindow/Position",
QVariant(QPoint(0, 0))).toPoint()
self.move(position)
self.restoreState(settings.value("MainWindow/State").toByteArray())
splitterState = settings.value("MainWindow/SplitState").toByteArray()
self.splitter.restoreState(splitterState)
# selected fields
self.dbName = bns.ConnectedDb.ConnectDb.GetList()
regKey = "Bionumerics/{0}/SelFields".format(self.dbName)
regBnFields = settings.value(regKey).toStringList()
self.bnSelectedFields = [unicode(item) for item in regBnFields]
regItFields = settings.value("ItemTracker/SelFields").toStringList()
self.itSelectedFields = [unicode(item) for item in regItFields]
# progress bar
self.progressBar = QProgressBar(self)
self.progressBar.setMaximumWidth(200)
self.statusbar.insertPermanentWidget(0, self.progressBar)
self.progressBar.hide()
# initialize variables
self.itemIds = {}
self.itemNames = {}
# bnFields - bionumerics information in the info panel
self.bnFields = {}
self.strainInfo = {}
# maintains list of keys that are updated
self.updatedStrains = []
self.selectRadioButton.setChecked(True)
self.itemProperties = {}
self.tableResults = []
self.getBnFields()
self.mkInfo("{0}. Log: {1}".format(time.asctime(), LOG_FNAME))
self.populatedTree = False
self.populatedTable = False
self.populatedCherry = False
idField = "ItemTracker ID" # Field with ItemTracker ID
self.itemIdsAll, errors = bn.getItemIds(idField, DB.Db.Entries)
if len(errors):
for key, message in errors.iteritems():
self.mkError("Key: {0}, {1}".format(key, message))
self.database = None
self.updateUi()
self.proxyModel = SortFilterProxyModel(self)
self.proxyModel.setDynamicSortFilter(True)
self.cherryView.setModel(self.proxyModel)
self.cherryView.setAlternatingRowColors(True)
self.cherryView.setSortingEnabled(True)
self.cherryView.verticalHeader().setVisible(False)
self.cherryView.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.cherryView.horizontalHeader().setStretchLastSection(True)
#self.populateTree() # testing
QTimer.singleShot(0, self.populateTree)
def bnSelectFields(self):
"""Bionumerics field selection dialog."""
try:
fieldNames = bn.getFieldNames()
except RuntimeError as e:
self.mkError("Failed to get Bionumerics field names: {0}".format(e))
dialog = selectfieldsdlg.selectFieldsDialog(fieldNames, self)
if self.bnSelectedFields is not None:
dialog.setSelected(self.bnSelectedFields)
if dialog.exec_():
self.bnSelectedFields = dialog.getSelected()
self.updateInfo()
def addCherryData(self, model, row):
"""Inserts row into model"""
model.insertRow(0)
for position, value in enumerate(row):
model.setData(model.index(0, position), value)
def createCherryModel(self, data, parent):
"""Creates a model for the tableview using data retrieved from the
cherry picking database.
"""
total = len(data)
self.progressBar.setMaximum(total)
self.progressBar.show()
model = QStandardItemModel(0, len(CHERRY_COLUMNS), parent)
for position, column in enumerate(CHERRY_COLUMNS):
model.setHeaderData(position, Qt.Horizontal, column)
# get additional data for each item
keys = [item[CHERRY_COLUMNS.index("Key")] for item in data]
itemIds = []
missing = []
itemIdsAll = dict((v, k) for k, v in self.itemIdsAll.iteritems())
for key in keys:
if key in itemIdsAll:
itemIds.append(itemIdsAll[key])
else:
missing.append(key)
if len(missing):
msg = ("Keys exist in cherry picking database but absent "
"in Bionumerics {0}".format(", ".join(missing)))
self.mkWarn(msg)
if not len(itemIds):
msg = "No entries in cherry picking database"
self.statusBar().showMessage(msg, 5000)
self.mkInfo(msg)
return None
itemIds = list(set(itemIds))
(dnaData, noData, errors) = lims.GetNewestDNAForCherryPicking(itemIds)
if len(noData):
msg = ", ".join(str(item) for item in noData)
self.mkWarn("{0}: {1}".format("No DNA's for these strains", msg))
if len(errors):
msg = ", ".join(errors)
self.mkError(msg)
for count, result in enumerate(data):
result = list(result)
key = result[0]
if key in itemIdsAll:
self.progressBar.setValue(count)
#QApplication.processEvents()
parentID = itemIdsAll[key]
if parentID in dnaData:
properties = dnaData[parentID]
for value in ("ItemName", "DNA concentration", "Volume",
"Freezer", "Rack", "Shelf", "PlateRack",
"Position"):
if value in properties:
result.append(properties[value])
else:
result.append("")
self.addCherryData(model, result)
return model
def cherryPicking(self):
"""Populate the cherry picking table"""
if self.populatedCherry:
if not self.stackedWidget.currentIndex() == 2:
self.stackedWidget.setCurrentIndex(2)
self.updateUi()
return
self.statusbar.showMessage("Getting data from cherry picking database")
db = DB.Db.Info.Name
cherryData = pgdb.get_data(db)
if not len(cherryData):
msg = "No cherry picking entries for this database"
self.statusbar.showMessage(msg, 5000)
self.mkInfo(msg)
self.stackedWidget.setCurrentIndex(2)
self.updateUi()
return
self.userComboBox.clear()
self.statusComboBox.clear()
# filter combo boxes
for label, combo in (("Username", self.userComboBox),
("Status", self.statusComboBox)):
position = CHERRY_COLUMNS.index(label)
comboItems = set([item[position] for item in cherryData])
combo.addItem("All")
combo.addItems(list(comboItems))
self.proxyModel.traceStatus = self.statusComboBox.currentText()
self.cherryView.reset()
self.cherryView.setDisabled(True)
self.statusbar.showMessage("Getting data from ItemTracker")
model = self.createCherryModel(cherryData, self)
if not model:
self.cherryView.setEnabled(False)
self.filterGroupBox.setDisabled(True)
else:
self.proxyModel.setSourceModel(model)
self.cherryView.setEnabled(True)
self.filterGroupBox.setEnabled(True)
self.cherryView.resizeColumnsToContents()
self.updateCounts()
self.stackedWidget.setCurrentIndex(2) # switch view to table
self.statusbar.clearMessage()
self.progressBar.setValue(len(cherryData))
self.progressBar.hide()
self.populatedCherry = True
self.updateUi()
def statusChanged(self):
"""Filter cherry picking based on current trace status from combo box."""
self.proxyModel.setTraceStatus(self.statusComboBox.currentText())
self.updateCounts()
def userChanged(self):
"""Filter cherry picking based on current user from combo box."""
user = self.userComboBox.currentText()
if user == "All":
user = "******"
regExp = QRegExp(user, Qt.CaseInsensitive, QRegExp.RegExp2)
self.proxyModel.setFilterRegExp(regExp)
self.updateCounts()
def updateCounts(self):
"""Update counts of strains, traces and DNA in cherry picking"""
strains = []
traces = self.proxyModel.rowCount()
dna = []
for i in range(traces):
for field, totals in (("Key", strains), ("DNA", dna)):
index = self.proxyModel.index(i, CHERRY_COLUMNS.index(field))
data = self.proxyModel.data(index).toString().trimmed()
if len(data) and data not in totals:
totals.append(data)
self.strainsLcdNumber.display(len(strains))
self.tracesLcdNumber.display(traces)
self.dnaLcdNumber.display(len(dna))
def getSaveFile(self, caption=""):
"""Opens the save file dialog and returns the file name."""
if not len(caption):
caption = "Save File As"
fn = QFileDialog.getSaveFileName(self, caption, self.dbPath,
"Text files (*.txt);;All Files (*.*)")
if fn:
if QFileInfo(fn).suffix().isEmpty():
fn += ".txt"
return fn
def exportTextFile(self, fh=None, header=None, data=None):
"""Writes data to the given file. Accepts column names and the data as
arguments
"""
if not fh:
self.mkError("Could not open file for writing")
return
if not data:
data = []
if not len(data):
self.mkWarn("No data to write")
return
fname = QFile(fh)
if fname.open(QFile.WriteOnly | QFile.Text):
txt = QTextStream(fname)
if header:
txt << ", ".join(col for col in header)
txt << "\n"
txt << "\n".join(", ".join(item) for item in data)
msg = "File export complete: {0}".format(str(fname.fileName()))
self.mkSuccess(msg)
def exportDNAList(self):
"""Export list of DNA's displayed in cherry picking."""
data = []
keys = []
columns = CHERRY_COLUMNS[:]
excludeColumns = ["Gene", "Orientation"]
exclude = []
for item in excludeColumns:
exclude.append(CHERRY_COLUMNS.index(item))
columns.remove(item)
keyIndex = CHERRY_COLUMNS.index("Key")
dnaIndex = CHERRY_COLUMNS.index("DNA")
for i in range(0, self.proxyModel.rowCount()):
# continue if key exists in keys
index = self.proxyModel.index(i, keyIndex)
key = self.proxyModel.data(index).toString()
if key in keys:
continue
# continue if DNA column is empty
index = self.proxyModel.index(i, dnaIndex)
dna = self.proxyModel.data(index).toString()
if dna.isEmpty():
continue
row = []
for j in range(self.proxyModel.columnCount()):
if j in exclude:
continue
index = self.proxyModel.index(i, j)
value = self.proxyModel.data(index).toString()
if not value.isEmpty():
row.append(str(value))
else:
row.append("")
data.append(row)
keys.append(key)
fh = self.getSaveFile("Export DNA List")
self.exportTextFile(fh, columns, data)
def exportTraceList(self):
"""Export list of traces displayed in cherry picking."""
data = []
for i in range(0, self.proxyModel.rowCount()):
row = []
for j in range(self.proxyModel.columnCount()):
index = self.proxyModel.index(i, j)
value = self.proxyModel.data(index).toString()
if not value.isEmpty():
row.append(str(value))
else:
row.append("")
data.append(row)
fh = self.getSaveFile("Export Trace List")
columns = CHERRY_COLUMNS[:]
self.exportTextFile(fh, columns, data)
def clearLog(self):
"""Clears the log window"""
self.logBrowser.clear()
def closeEvent(self, event):
"""Called on closing the window. Save settings and exit."""
self.handler.close()
self.logger.removeHandler(self.handler)
if self.okToContinue():
settings = QSettings()
settings.setValue("MainWindow/Size", QVariant(self.size()))
settings.setValue("MainWindow/Position", QVariant(self.pos()))
settings.setValue("MainWindow/State", QVariant(self.saveState()))
settings.setValue("MainWindow/SplitState",
self.splitter.saveState())
bnSelectedFields = QVariant(self.bnSelectedFields) \
if self.bnSelectedFields else QVariant()
regkey = "Bionumerics/{0}/SelFields".format(self.dbName)
settings.setValue(regkey, bnSelectedFields)
itSelectedFields = QVariant(self.itSelectedFields) \
if self.itSelectedFields else QVariant()
settings.setValue("ItemTracker/SelFields", itSelectedFields)
else:
event.ignore()
def collapseItem(self):
"""Collapse selected item."""
try:
selected = self.treeWidget.selectedItems()[0]
except IndexError:
selected = None
self.statusbar.showMessage("No item selected", 2000)
if selected:
self.treeWidget.collapseItem(selected)
def collapseAll(self):
"""Collapse all items."""
self.treeWidget.collapseAll()
def disableWidgets(self, widgets):
"""Disable group of widgets. Does not change visibility."""
for widget in widgets:
if widget.isEnabled():
widget.setDisabled(True)
def enableWidgets(self, widgets):
"""Enable group of widgets. Set visible if not visible."""
for widget in widgets:
if not widget.isEnabled():
widget.setEnabled(True)
if not widget.isVisible():
widget.setVisible(True)
def expandItem(self):
"""Expand selected item."""
try:
selected = self.treeWidget.selectedItems()[0]
except IndexError:
selected = None
self.statusbar.showMessage("No item selected", 2000)
if selected:
self.treeWidget.expandItem(selected)
def expandAll(self):
"""Expands all items."""
self.treeWidget.expandAll()
def getBnFields(self):
"""Get bionumerics field information required for the info panel."""
bnFields = bn.getFieldNames()
strainFields = ["Strain", "STRAIN"]
for field in strainFields:
if (field in bnFields) and (field not in self.bnSelectedFields):
self.bnSelectedFields.append(field)
for key in self.selectedIds.values():
if not self.bnFields.get(key):
self.bnFields[key] = bn.getSelectedFields(key, bnFields)
def getParent(self, item):
"""Returns the top level parent of an item."""
parentItem = None
while item.parent():
parentItem = item.parent()
item = parentItem
return parentItem
def getData(self, items, itemid):
"""Returns parent and children for data received from GetDictionary."""
if len(items):
children = items[itemid].keys()
yield itemid, children
items = items[itemid]
for child in children:
for res in self.getData(items, child):
yield res
return
def getAllItemIds(self):
"""Gets all ItemTracker IDs in the current Bionumerics database."""
itemIds = {}
field = "ItemTracker ID"
value = None
for i in range(len(DB.Db.Entries)):
value = DB.Db.Entries[i].Field(field).Content
# bugfix: don't display if ItemTracker ID contains spaces
value = value.strip()
if not len(value):
continue
key = DB.Db.Entries[i].Key
key = key.strip()
if key in itemIds:
itemIds.pop(key)
msg = "Duplicate keys in database: {0}. Not processed".format(key)
self.mkWarn(msg)
continue
try:
value = int(value)
except (ValueError, TypeError):
self.mkWarn("Invalid ItemTracker ID {0} for entry "
"{1} in Bionumerics".format(value, key))
if isinstance(value, int):
if value in itemIds.values():
msg = ("Duplicate ItemTracker ID: {0}. "
"Keys: {1}, ".format(value, key))
for k, v in itemIds.items():
if v == value:
itemIds.pop(k)
msg += k
self.mkWarn(msg)
else:
itemIds[key] = value
return itemIds
def getAllSelected(self):
"""Get all selected items by user."""
if self.populatedTable:
self.stackedWidget.setCurrentIndex(1)
self.updateUi()
return
msg = "Getting all selected entries from ItemTracker. Please wait..."
self.statusbar.showMessage(msg)
if len(self.itemIdsAll):
try:
self.tableResults = \
lims.SelectAllselectedEntries(self.itemIdsAll.keys())
except:
raise RuntimeError
else:
self.mkInfo("No ItemTracker IDs to process")
if not len(self.tableResults):
user = os.environ.get("USERNAME")
msg = "No selected entries for user {0}".format(user)
self.statusbar.showMessage(msg, 5000)
self.mkInfo(msg)
self.stackedWidget.setCurrentIndex(1)
self.populatedTable = False
self.updateUi()
else:
QTimer.singleShot(0, self.populateTable)
def getItemtrackerFields(self):
"""Returns all ItemTracker fields returned from GetDictionary."""
fields = []
alwaysFields = ["ItemID", "ItemName", "Position"]
for item in self.itemProperties:
for field in self.itemProperties[item].keys():
if (field not in fields) and (field not in alwaysFields):
fields.append(field)
return fields
def getWidget(self):
"""Returns the current active widget."""
index = self.stackedWidget.currentIndex()
if index == 0:
widget = self.treeWidget
elif index == 1:
widget = self.selectedWidget
elif index == 2:
widget = self.cherryView
return widget
def about(self):
"""About box."""
import platform
msg = """\
<b>IT Query</b> version {0} <p>An interface to query
ItemTracker from Bionumerics</p>Python {1} - Qt {2} -
PyQt {3} on {4}\
""".format(__version__, platform.python_version(),
QT_VERSION_STR, PYQT_VERSION_STR, platform.system())
msg += """<br>Icons from the
<a href="http://www.oxygen-icons.org/">Oxygen project</a>
</p>"""
QMessageBox.about(self, "About IT Query", msg)
def legend(self):
"""A simple dialog displaying the color legend used in treeview."""
dialog = legenddlg.legendDialog(self)
dialog.exec_()
def itSelectFields(self):
"""ItemTracker field selection dialog."""
fieldNames = self.getItemtrackerFields()
dialog = selectfieldsdlg.selectFieldsDialog(fieldNames, self)
if self.itSelectedFields is not None:
dialog.setSelected(self.itSelectedFields)
if dialog.exec_():
self.itSelectedFields = dialog.getSelected()
self.updateInfo()
def mkWarn(self, msg):
"""Orange color"""
bgColor = "235,115,49"
self.mkTable(bgColor, "WARNING", msg)
def mkError(self, msg):
"""Red color"""
bgColor = "226,8,0"
self.mkTable(bgColor, "ERROR", msg)
def mkSuccess(self, msg):
"""Green color"""
bgColor = "55,164,44"
self.mkTable(bgColor, "SUCCESS", msg)
def mkInfo(self, msg):
"""Blue color"""
bgColor = "0,87,174"
self.mkTable(bgColor, "INFO", msg)
def mkTable(self, bgColor, status, msg):
"""Formats message displayed in the log window."""
formatStatus = ('<font style="color:rgb({0})"><strong>{1}</strong>'
'</font>'.format(bgColor, status))
self.logBrowser.append("{0}: {1}".format(formatStatus, msg))
def okToContinue(self):
"""Check before closing."""
if len(self.updatedStrains):
reply = QMessageBox(QMessageBox.Question,
"Selection", "Entry selection in Bionumerics",
QMessageBox.NoButton, self)
originalButton = QPushButton("Keep Original Selection")
updatedButton = QPushButton("Updated Items Only")
cancelButton = QPushButton("Cancel")
reply.addButton(originalButton, QMessageBox.ActionRole)
reply.addButton(updatedButton, QMessageBox.ActionRole)
reply.addButton(cancelButton, QMessageBox.RejectRole)
reply.exec_()
if reply.clickedButton() == cancelButton:
return False
elif reply.clickedButton() == originalButton:
bn.selectEntries(self.selectedIds.values() +\
self.errorIds.keys())
elif reply.clickedButton() == updatedButton:
bn.selectEntries(self.updatedStrains)
return True
def populateTable(self):
"""Populates table with data from ItemTracker."""
self.selectedWidget.clear()
self.selectedWidget.setSortingEnabled(False)
numRows = len(self.tableResults)
self.mkInfo("Selected items in ItemTracker: {0}".format(numRows))
self.selectedWidget.setAlternatingRowColors(True)
header = ["ItemID", "StrainID", "ItemType", "ItemName", "BacteriaItemID"]
self.selectedWidget.setColumnCount(len(header))
self.selectedWidget.setHeaderLabels(header)
# use result and populate table
for result in self.tableResults:
properties = [unicode(i) for i in result]
item = QTreeWidgetItem(self.selectedWidget, properties)
item.setCheckState(0, Qt.Unchecked)
self.selectedWidget.setSortingEnabled(True)
for i in range(len(header)):
self.selectedWidget.resizeColumnToContents(i)
self.stackedWidget.setCurrentIndex(1) # switch view to table
self.statusbar.clearMessage()
self.populatedTable = True
self.updateUi()
def populateTree(self):
"""Populates tree view with information from ItemTracker."""
if len(self.errorIds):
self.mkError("{0} entries do not have valid "
"ItemTracker IDs in Bionumerics.".format(len(self.errorIds)))
for key, msg in self.errorIds.iteritems():
self.mkError("KEY: {0} {1}".format(key, msg))
if not len(self.selectedIds):
self.statusbar.showMessage("No items to process", 5000)
return
parents = {}
headers = ["Items", "Selected", "SelectedBy", "Viability", "Volume",
"DNA concentration", "UserName", "TubePresent", "InputDate",
"AlternID", "Status"]
self.treeWidget.setItemsExpandable(True)
self.treeWidget.setAlternatingRowColors(True)
self.treeWidget.setColumnCount(len(headers))
self.treeWidget.setHeaderLabels(headers)
msg = "Getting information from ItemTracker. Please wait..."
self.statusbar.showMessage(msg)
self.progressBar.setMinimum(0)
self.progressBar.setMaximum(0)
self.progressBar.show()
(treeData, self.itemProperties,
message) = lims.GetDictionary((self.selectedIds.keys()))
if len(message):
for msg in message:
self.mkError("ItemTracker error: {0}".format(msg))
if not len(treeData):
self.mkError("Could not get data from ItemTracker for"
"selected entries")
self.statusBar().clearMessage()
self.progressBar.hide()
self.updateUi()
return
# bugfix: If ItemType property does not exist for the first item
# self.database is not set and tree view is not updated.
db = None
if not self.database:
for item in self.itemProperties.values():
try:
db = item["ItemType"]
except KeyError:
pass
if db == "Salmonella":
self.database = db
break
elif db == "Listeria":
self.database = db
break
self.progressBar.setMaximum(len(treeData))
count = 0
for key, value in treeData.iteritems():
count += 1
self.progressBar.setValue(count)
if not(value and isinstance(value, dict)):
self.mkWarn("No data returned for key {0}".format(key))
continue
items = {}
items[key] = value
for results in self.getData(items, key):
parent = parents.get(results[0])
if not parent:
parent_id = self.selectedIds[results[0]]
self.strainInfo[parent_id] = {self.database:[],
"Frozen Stock":[], "DNA":[]}
parent = QTreeWidgetItem(self.treeWidget,
[unicode(parent_id)])
brush = QBrush()
brush.setColor(Qt.blue)
parent.setForeground(0, brush)
parent.setIcon(0, QIcon(":/branch-closed.png"))
parent.setData(0, Qt.CheckStateRole, QVariant())
parents[results[0]] = parent
for children in results[1]:
itemName = self.itemProperties[children]["ItemName"]
if not self.itemIds.get(itemName):
self.itemIds[itemName] = children
childprops = []
childprops.append(unicode(itemName))
for header in headers[1:]:
try:
childprop = self.itemProperties[children][header]
if childprop is None or childprop == "":
childprops.append(unicode(""))
else:
childprops.append(unicode(childprop))
except KeyError:
childprops.append(unicode(""))
continue
childs = parents.get(children)
if not childs:
childs = QTreeWidgetItem(parent, childprops)
if self.itemProperties[children]["TubePresent"] == "-":
childs.setBackgroundColor(0, QColor(232, 87, 82))
childs.setForeground(0, QColor(255, 255, 255))
if self.itemProperties[children]["Selected"] == "yes":
childs.setBackgroundColor(0, QColor(119, 183, 83))
childs.setForeground(0, QColor(255, 255, 255))
itype = self.itemProperties[children]["ItemType"]
if itype:
self.strainInfo[parent_id][itype].append(itemName)
parents[children] = childs
childs.setCheckState(0, Qt.Unchecked)
self.treeWidget.expandAll()
for i in range(len(headers)):
self.treeWidget.resizeColumnToContents(i)
if not self.treeWidget.isEnabled():
self.treeWidget.setEnabled(True)
self.mkInfo("Processed <b>{0}</b> entries".format(len(treeData)))
self.progressBar.setValue(len(treeData))
self.progressBar.hide()
self.populatedTree = True
self.updateUi()
self.statusbar.showMessage("Ready", 5000)
def selectAll(self):
"""All items are selected (checked)."""
index = self.stackedWidget.currentIndex()
widget = self.getWidget()
it = QTreeWidgetItemIterator(widget, QTreeWidgetItemIterator.NotChecked)
count = 0
if index == 0:
while it.value():
if it.value().parent():
it.value().setCheckState(0, Qt.Checked)
count += 1
it += 1
elif index == 1:
while it.value():
it.value().setCheckState(0, Qt.Checked)
count += 1
it += 1
if count:
self.statusbar.showMessage("Selected {0} items".format(count), 3000)
def selectDNA(self):
"""Select all DNA items."""
self.selectItems("DNA")
def selectFrozenStock(self):
"""Select all Frozen Stock items."""
self.selectItems("Frozen Stock")
def selectNone(self):
"""Clears the selection."""
widget = self.getWidget()
it = QTreeWidgetItemIterator(widget, QTreeWidgetItemIterator.Checked)
while it.value():
it.value().setCheckState(0, Qt.Unchecked)
it += 1
def selectInvert(self):
"""Inverts the selection."""
index = self.stackedWidget.currentIndex()
widget = self.getWidget()
it = QTreeWidgetItemIterator(widget)
if index == 0:
while it.value():
if it.value().parent():
if it.value().checkState(0) == Qt.Checked:
it.value().setCheckState(0, Qt.Unchecked)
else:
it.value().setCheckState(0, Qt.Checked)
it += 1
else:
while it.value():
if it.value().checkState(0) == Qt.Checked:
it.value().setCheckState(0, Qt.Unchecked)
else:
it.value().setCheckState(0, Qt.Checked)
it += 1
def selectItems(self, itemType):
"""Select all items of a given ItemType."""
self.statusbar.showMessage("Selecting all {0}'s. "
"Please wait...".format(itemType))
items = []
itemsAll = []
index = self.stackedWidget.currentIndex()
if index == 0:
position = 0
items = [item[itemType] for item in self.strainInfo.values()]
for item in items:
if len(item):
itemsAll += item
else:
position = 3
for item in self.tableResults:
if item[2] == itemType:
itemsAll.append(item[3])
if not len(itemsAll):
self.statusbar.showMessage("No {0}'s in list".format(itemType), 5000)
return
self.selectNone()
widget = self.getWidget()
it = QTreeWidgetItemIterator(widget)
while it.value():
if it.value().text(position) in itemsAll:
it.value().setCheckState(0, Qt.Checked)
it += 1
self.statusbar.showMessage("Selected {0} {1}'s".format(len(itemsAll),
itemType), 3000)
def selectInBionumerics(self, on):
"""Selects Bionumerics entries with checked items from table view
(get all selected)
"""
actionGroup = QActionGroup(self)
actionGroup.addAction(self.actionViewTree)
actionGroup.addAction(self.refresh_action)
actionGroup.addAction(self.actionSelectAll)
actionGroup.addAction(self.actionSelectInvert)
actionGroup.addAction(self.actionSelectNone)
actionGroup.addAction(self.actionSelectDNA)
actionGroup.addAction(self.actionSelectFrozenStock)
if on:
actionGroup.setEnabled(False)
if not len(self.itemNames):
self.itemNames = bn.createIdMap()
it = QTreeWidgetItemIterator(self.selectedWidget,
QTreeWidgetItemIterator.Checked)
checkedItems = []
while it.value():
parentCode = unicode(it.value().text(4))
bnStrain = self.itemNames[int(parentCode)]
if bnStrain not in checkedItems:
checkedItems.append(bnStrain)
it += 1
if len(checkedItems):
bn.selectEntries(checkedItems)
else:
self.statusbar.showMessage("No items checked", 3000)
else:
actionGroup.setEnabled(True)
bn.selectEntries(self.selectedIds.values() + self.errorIds.keys())
def updateSelection(self):
"""Updates selection status in ItemTracker."""
if self.actionSelectInBionumerics.isChecked():
self.selectInBionumerics(False)
self.actionSelectInBionumerics.setChecked(False)
self.updateButton.setEnabled(False)
self.statusbar.showMessage("Updating selection. Please wait...")
if self.selectRadioButton.isChecked():
selectedAction = "SELECT"
elif self.deselectRadioButton.isChecked():
selectedAction = "DESELECT"
checkedItems = {}
updatedItems = []
failedItems = []
index = self.stackedWidget.currentIndex()
widget = self.getWidget()
it = QTreeWidgetItemIterator(widget, QTreeWidgetItemIterator.Checked)
if index == 0:
while it.value():
itemName = unicode(it.value().text(0))
itemId = self.itemIds[itemName]
checkedItems[itemName] = itemId
parentItem = self.getParent(it.value())
strain = unicode(parentItem.text(0))
if strain not in self.updatedStrains:
self.updatedStrains.append(strain)
it += 1
elif index == 1:
if not len(self.itemNames):
self.itemNames = bn.createIdMap()
while it.value():
itemId = unicode(it.value().text(0))
itemName = unicode(it.value().text(3))
checkedItems[itemName] = int(itemId)
parentCode = unicode(it.value().text(4))
strain = self.itemNames[int(parentCode)]
if strain not in self.updatedStrains:
self.updatedStrains.append(strain)
it += 1
if not len(checkedItems):
self.statusbar.showMessage("No items checked", 5000)
self.updateButton.setEnabled(True)
return
for itemName, itemId in checkedItems.iteritems():
if selectedAction == "SELECT":
result = lims.SelectItem(itemId)
elif selectedAction == "DESELECT":
result = lims.UnselectItem(itemId)
if not len(result):
updatedItems.append(itemName)
else:
failedItems.append(itemName)
if len(updatedItems):
self.mkSuccess("{0}ED {1} items".format(selectedAction,
len(updatedItems)))
self.logBrowser.append("{0}".format(", ".join(updatedItems)))
self.logger.info("{0}\t{1}".format(selectedAction, ", ".join(updatedItems)))
if len(failedItems):
self.mkError("{0} failed for {1} items".format(selectedAction,
len(failedItems)))
self.logBrowser.append("{0}".format(", ".join(failedItems)))
self.logger.info("{0}\t{1}".format(selectedAction,
", ".join(failedItems)))
self.updateButton.setEnabled(True)
if len(updatedItems) or len(failedItems):
self.populatedTree = False
self.populatedTable = False
self.refresh()
def updateUi(self):
"""Updates interface based on the view."""
index = self.stackedWidget.currentIndex()
# only show export actions in cherry picking
if index != 2:
widgets = [self.exportToolBar, self.exportActions]
self.disableWidgets(widgets)
for widget in widgets:
widget.setVisible(False)
# disable select menu in cherry picking (not implemented)
if index == 2:
self.selectMenu.setEnabled(False)
else:
self.selectMenu.setEnabled(True)
if index == 0: # Tree View
self.disableWidgets([self.actionViewTree,
self.actionSelectInBionumerics])
self.enableWidgets([self.actionGetAllSelected,
self.actionCherryPicking])
for widget in [self.actionSelectInBionumerics,
self.getSelectedToolBar]:
widget.setVisible(False)
#self.fieldsGroupBox.setVisible(True)
widgets = [self.widget, self.treeWidget, self.selectGroupBox,
self.fieldsGroupBox, self.actionLegend, self.treeToolBar,
self.treeActions, self.selectActions]
for widget in widgets:
if not widget.isVisible():
widget.setVisible(True)
if self.populatedTree:
self.enableWidgets(widgets)
else:
self.disableWidgets(widgets)
try:
self.treeWidget.selectedItems()[0]
except IndexError:
self.infoBrowser.setDisabled(True)
self.fieldsGroupBox.setEnabled(self.infoBrowser.isEnabled())
elif index == 1:
self.widget.setVisible(True)
self.enableWidgets([self.actionViewTree, self.actionCherryPicking])
self.actionSelectInBionumerics.setVisible(True)
self.getSelectedToolBar.setVisible(True)
for widget in [self.actionLegend, self.fieldsGroupBox,
self.treeToolBar, self.treeActions]:
widget.setVisible(False)
self.disableWidgets([self.actionGetAllSelected, self.actionLegend,
self.treeToolBar, self.treeActions])
widgets = [self.widget, self.selectedWidget, self.selectGroupBox,
self.actionSelectInBionumerics, self.getSelectedToolBar,
self.selectActions]
if self.populatedTable:
self.enableWidgets(widgets)
else:
self.disableWidgets(widgets)
elif index == 2:
self.widget.setVisible(False) # ItemTracker and field selection
self.actionCherryPicking.setEnabled(False)
self.exportToolBar.setVisible(True)
self.exportActions.setVisible(True)
for action in [self.actionViewTree, self.actionGetAllSelected]:
action.setEnabled(True)
widgets = [self.selectActions, self.actionSelectInBionumerics,
self.actionLegend, self.treeActions, self.treeToolBar,
self.getSelectedToolBar]
self.disableWidgets(widgets)
for widget in widgets:
widget.setVisible(False)
widgets = [self.cherryView, self.filterGroupBox, self.lcdGroupBox,
self.exportActions, self.exportToolBar]
if self.populatedCherry:
self.enableWidgets(widgets)
else:
self.disableWidgets(widgets)
def updateInfo(self):
"""Infobar displaying ItemTracker and Bionumerics fields."""
content = ('<table border="0" cellspacing="0" '
'cellpadding="5" width="100%">')
self.infoBrowser.clear()
try:
selected = self.treeWidget.selectedItems()[0]
except IndexError:
return
else:
self.infoBrowser.setEnabled(True)
self.fieldsGroupBox.setEnabled(True)
try:
parentName = self.getParent(selected).text(0)
except AttributeError:
parentName = None
if parentName:
itemName = unicode(selected.text(0))
itemId = self.itemIds[itemName]
if itemId:
content += """\
<tr bgcolor="#85026C">
<th colspan="2" align="left">
<font color="white">ITEMTRACKER</font>
</th>
</tr>\
"""
count = 0
for field, value in (("Strain", parentName),
("Item Name", itemName),
("Item ID", itemId)):
if count % 2 == 0:
content += """\
<tr>
<td>{0}</td>
<td>{1}</td>
</tr>\
""".format(field, value)
else:
content += """\
<tr bgcolor="#eee">
<td>{0}</td>
<td>{1}</td>
</tr>\
""".format(field, value)
count += 1
try:
properties = self.itemProperties[int(itemId)]
except KeyError:
self.mkWarn("Could not get properties for "
"ItemTracker ID {0}".format(itemId))
if len(properties):
try:
location = properties["Position"]
except KeyError:
location = []
if len(location):
for field, value in (("Freezer", location[0]),
("Rack", location[1]),
("Shelf", location[2]),
("Plate Rack", location[3]),
("Position", location[4])):
if count % 2 == 0:
content += """\
<tr>
<td>{0}</td>
<td>{1}</td>
</tr>\
""".format(field, value)
else:
content += """\
<tr bgcolor="#eee">
<td>{0}</td>
<td>{1}</td>
</tr>\
""".format(field, value)
count += 1
if len(self.itSelectedFields):
for itField in self.itSelectedFields:
try:
itemProperty = properties[itField]
except KeyError:
itemProperty = ""
if count % 2 == 0:
content += """\
<tr>
<td>{0}</td>
<td>{1}</td>
</tr>\
""".format(itField, itemProperty)
else:
content += """\
<tr bgcolor="#eee">
<td>{0}</td>
<td>{1}</td>
</tr>\
""".format(itField, itemProperty)
count += 1
else:
content += """\
<tr>
<td colspan="2">No information</td>
</tr>"""
self.infoBrowser.setHtml(QString(content))
content += """\
<tr bgcolor="#CF4913">
<th colspan="2" align="left">
<font color="white">BIONUMERICS</font>
</th>
</tr>\
"""
strainInfo = {}
try:
strainInfo = self.bnFields.get(unicode(parentName))
except KeyError:
self.mkWarn("Could not get information for {0}".format(parentName))
if len(strainInfo):
count = 0
for field in self.bnSelectedFields:
if count % 2 == 0:
content += """\
<tr>
<td>{0}</td>
<td>{1}</td>
</tr>\
""".format(field, strainInfo[field])
else:
content += """\
<tr bgcolor="#eee">
<td>{0}</td>
<td>{1}</td>
</tr>\
""".format(field, strainInfo[field])
count += 1
else:
self.mkWarn("No information for {0}".format(parentName))
content += "</table>"
else:
strainName = unicode(selected.text(0))
itemId = None
for ids, keys in self.selectedIds.iteritems():
if keys == strainName:
itemId = ids
break
if not itemId:
self.infoBrowser.setHtml(QString(content))
return
content = """\
<table border="0" cellpadding="5" cellspacing="0" width="100%">
<tr bgcolor="#85026C">
<th colspan="2" align="left">
<font color="white">ITEMTRACKER</font>
</th>
</tr>
<tr bgcolor="#eee">
<td>AlternID</td>
<td>{0}</td>
</tr>
<tr>
<td>OriginalID</td>
<td>{1}</td>
</tr>\
""".format(self.itemProperties[itemId]["AlternID"],
self.itemProperties[itemId]["OriginalID"])
content += "</table>"
content += """\
<table border="0" cellpadding="5" cellspacing="0" width="100%">
<tr bgcolor="#BF0361">
<th align="left">
<font color="white">{0}</font>
</th>
<th align="right">
<font color="white">{1}</font>
</th>
</tr>
<tr>
<td colspan="2">{2}</td>
</tr>\
""".format(self.database.upper(),
len(self.strainInfo[strainName][self.database]),
", ".join(self.strainInfo[strainName][self.database]))
content += """\
<tr bgcolor="#00438A">
<th align="left">
<font color="white">FROZEN STOCK</font>
</th>
<th align="right">
<font color="white">{0}</font>
</th>
</tr>
<tr>
<td colspan="2">{1}</td>
</tr>\
""".format(len(self.strainInfo[strainName]["Frozen Stock"]),
", ".join(self.strainInfo[strainName]["Frozen Stock"]))
content += """\
<tr bgcolor="#00734D">
<th align="left">
<font color="white">DNA</font>
</th>
<th align="right">
<font color="white">{0}</font>
</th>
</tr>
<tr>
<td colspan="2">{1}</td>
</tr>\
""".format(len(self.strainInfo[strainName]["DNA"]),
", ".join(self.strainInfo[strainName]["DNA"]))
content += "</table>"
self.infoBrowser.setHtml(QString(content))
def viewTree(self):
"""Toolbar button/action to switch to tree view."""
self.selectRadioButton.setChecked(True)
if not self.populatedTree:
self.stackedWidget.setCurrentIndex(0)
self.refresh()
self.stackedWidget.setCurrentIndex(0)
self.updateUi()
def refresh(self):
"""Updates view(s)."""
index = self.stackedWidget.currentIndex()
if index == 1:
self.populatedTable = False
self.selectedWidget.clear()
self.getAllSelected()
elif index == 0:
self.populatedTree = False
self.treeWidget.clear()
self.treeWidget.setDisabled(True)
bnField = "ItemTracker ID"
self.selectedIds = {}
self.errorIds = {}
selection = DB.Db.Selection
self.selectedIds, self.errorIds = bn.getItemIds(bnField, selection)
if len(self.selectedIds):
self.strainInfo = {}
self.itemIds = {}
self.getBnFields()
# self.populateTree()
QTimer.singleShot(0, self.populateTree)
elif index == 2:
self.populatedCherry = False
QTimer.singleShot(0, self.cherryPicking)
self.updateUi()
class GUI(QWidget):
def __init__(self, parent=None):
super(GUI, self).__init__(parent)
self.create_ui_components()
self.compose_ui()
# Initializing: window composition, it's contents and event handlers
self.init_composition()
self.init_contents()
self.init_actions()
self.on_start()
def create_ui_components(self):
"""
Create layouts and qt controls.
"""
self.layout = QGridLayout()
self.kanjiGroup = QGroupBox()
self.kanjiLayout = QGridLayout()
# Kanji ui group
self.day, self.week, self.month, self.year = \
QLabel(KANJI), QLabel(KANJI), QLabel(KANJI), QLabel(KANJI)
self.dayLabel, self.weekLabel, self.monthLabel, self.yearLabel = \
QLabel('<b>Day</b>'), QLabel('<b>Week</b>'), \
QLabel('<b>Month</b>'), QLabel('<b>Year</b>')
# Main layout
self.showAbout = QPushButton('A&bout')
# DB controls (top)
self.showDB, self.availableDB, self.changeDB = \
QPushButton('&Change DB (active:)'), QComboBox(), QPushButton('&Remap')
# General controls (bottom)
self.getAll, self.showStats, self.quitApp, self.authGen, self.methodCombo = \
QPushButton('&Get all'), QPushButton('&Stats'), QPushButton('&Quit'), \
QPushButton('&Auth'), QComboBox()
# Notifications
self.progressBar = QProgressBar()
self.statusMessage = QLabel()
# About
self.aboutBox = QMessageBox()
def compose_ui(self):
"""
Fill layouts and groups, initialize filters.
"""
self.kanjiLayout.addWidget(self.day, 0, 0)
self.kanjiLayout.addWidget(self.week, 0, 1)
self.kanjiLayout.addWidget(self.dayLabel, 1, 0)
self.kanjiLayout.addWidget(self.weekLabel, 1, 1)
self.kanjiLayout.addWidget(self.month, 2, 0)
self.kanjiLayout.addWidget(self.year, 2, 1)
self.kanjiLayout.addWidget(self.monthLabel, 3, 0)
self.kanjiLayout.addWidget(self.yearLabel, 3, 1)
self.kanjiGroup.setLayout(self.kanjiLayout)
self.layout.addWidget(self.showDB, 0, 0, 1, 2)
self.layout.addWidget(self.availableDB, 1, 0)
self.layout.addWidget(self.changeDB, 1, 1)
self.layout.addWidget(self.kanjiGroup, 2, 0, 1, 2)
self.layout.addWidget(self.getAll, 3, 0)
self.layout.addWidget(self.showStats, 3, 1)
self.layout.addWidget(self.methodCombo, 4, 0)
self.layout.addWidget(self.authGen, 4, 1)
#self.layout.addWidget(self.quitApp, 5, 0, 1, 2)
self.layout.addWidget(self.quitApp, 5, 0)
self.layout.addWidget(self.showAbout, 5, 1)
self.layout.addWidget(self.progressBar, 6, 0, 1, 2)
self.layout.addWidget(self.statusMessage, 7, 0, 1, 2)
self.setLayout(self.layout)
self.eFilter = LabelEventFilter()
def on_start(self):
"""
Additional procedures run on application start.
"""
# Let's initialize even some stuff!
self.al = None
self.auth_thread = None
self.init_backend()
choose_db(str(self.availableDB.currentText()))
self.showDB.setText("&Change DB (active: %s)" %
self.availableDB.currentText())
self.stats = StatsUI(self.al, self)
def init_composition(self):
"""
Window composition and general params.
"""
self.setWindowTitle(NAME + ' ' + __version__)
desktop = QApplication.desktop()
self.setGeometry((desktop.width() - WIDTH) / 2,
(desktop.height() - HEIGHT) / 2, WIDTH, HEIGHT)
def init_contents(self):
"""
Setting up qt controls.
"""
self.changeDB.hide()
self.availableDB.hide()
self.availableDB.addItems(dbs.keys())
self.kanjiGroup.setAlignment(Qt.AlignCenter)
self.kanjiGroup.setStyleSheet(
"QGroupBox { border: 1px solid gray; border-radius: 3px; }")
self.day.setAlignment(Qt.AlignCenter)
self.week.setAlignment(Qt.AlignCenter)
self.month.setAlignment(Qt.AlignCenter)
self.year.setAlignment(Qt.AlignCenter)
self.dayLabel.setAlignment(Qt.AlignCenter)
self.weekLabel.setAlignment(Qt.AlignCenter)
self.monthLabel.setAlignment(Qt.AlignCenter)
self.yearLabel.setAlignment(Qt.AlignCenter)
self.day.setFont(QFont(PRETTY_FONT, KANJI_SIZE))
self.week.setFont(QFont(PRETTY_FONT, KANJI_SIZE))
self.month.setFont(QFont(PRETTY_FONT, KANJI_SIZE))
self.year.setFont(QFont(PRETTY_FONT, KANJI_SIZE))
self.methodCombo.addItems(RandomMess.algs.keys())
self.methodCombo.setCurrentIndex(1)
self.statusMessage.setAlignment(Qt.AlignCenter)
self.statusMessage.hide()
self.statusMessage.setMaximumHeight(MESSAGE_HEIGHT)
self.statusMessage.setStyleSheet(WARNING_STYLE)
self.progressBar.setMaximum(0)
self.progressBar.setMaximumHeight(PROGRESS_HEIGHT)
self.progressBar.hide()
QToolTip.setFont(QFont(PRETTY_FONT, TOOLTIP_FONT_SIZE))
self.getAll.setToolTip('Randomly select all 4 kanji')
self.methodCombo.setToolTip('Choose algorithm for randomness')
self.authGen.setToolTip('Authorize on remote RNG services')
self.showStats.setToolTip(
'Show/hide dialog with comprehensive statistics')
self.quitApp.setToolTip('Close application')
self.showDB.setToolTip('Show/hide available databases')
self.availableDB.setToolTip('Available kanji frequency charts db')
self.changeDB.setToolTip('Pick new kanji from currently selected db')
# About dialog
self.aboutBox.layout().itemAt(1).widget().setAlignment(Qt.AlignLeft)
self.aboutBox.setTextFormat(Qt.RichText)
self.aboutBox.setText('Version:\t<b>' + __version__ +
'</b><br/>Python:\t<b>' +
platform.python_version() + '</b>' +
'<br/>Platform:\t<b>' + platform.system() + ' ' +
platform.release() + '</b>' +
'<br/>Author:\t<b>' + __author__ + '</b>' +
app_about)
self.aboutBox.setWindowTitle('About ' + app_name)
self.aboutBox.setIconPixmap(QPixmap(paths['icon']))
def init_actions(self):
"""
Binding events/handlers.
"""
self.showDB.clicked.connect(self.show_available_db)
self.changeDB.clicked.connect(self.change_db)
self.quitApp.clicked.connect(self.close)
self.getAll.clicked.connect(self.get_all)
self.authGen.clicked.connect(self.auth_task)
self.showStats.clicked.connect(self.show_stats)
self.methodCombo.currentIndexChanged.connect(self.update_alg)
self.showAbout.clicked.connect(self.app_help)
# Mouse events for labels
self.day.setAttribute(Qt.WA_Hover, True)
self.week.setAttribute(Qt.WA_Hover, True)
self.month.setAttribute(Qt.WA_Hover, True)
self.year.setAttribute(Qt.WA_Hover, True)
self.day.installEventFilter(self.eFilter)
self.week.installEventFilter(self.eFilter)
self.month.installEventFilter(self.eFilter)
self.year.installEventFilter(self.eFilter)
##### actions #####
def show_stats(self):
if self.stats.isVisible():
self.stats.hide()
else:
self.stats.show()
def show_available_db(self):
if self.availableDB.isVisible():
self.availableDB.hide()
self.changeDB.hide()
else:
self.availableDB.show()
self.changeDB.show()
def change_db(self):
try:
choose_db(str(self.availableDB.currentText()))
self.availableDB.hide()
self.changeDB.hide()
self.show_message_then_hide("DB successfully remaped!", False)
self.showDB.setText("&Change DB (active: %s)" %
self.availableDB.currentText())
self.stats.update_stat_info()
self.stats.refresh_plot()
except NoDbException as e:
self.show_message_then_hide(e.message)
def get_all(self):
self.random_kanji_task = RandomKanjiTask(self.al)
self.random_kanji_task.done.connect(self.update_kanji)
self.show_progress('Selecting kanji...')
self.random_kanji_task.start()
def update_kanji(self, results):
if results['success']:
kanji_set = results['kanji_set']
for_a_day = kanji_set.pop()
for_a_week = kanji_set.pop()
for_a_month = kanji_set.pop()
for_a_year = kanji_set.pop()
self.day.setText(for_a_day.character)
self.dayLabel.setText('<b>Day:</b> ' + str(for_a_day.frequency) +
' | ' + str(for_a_day.dominance) + '%')
self.week.setText(for_a_week.character)
self.weekLabel.setText('<b>Week:</b> ' +
str(for_a_week.frequency) + ' | ' +
str(for_a_week.dominance) + '%')
self.month.setText(for_a_month.character)
self.monthLabel.setText('<b>Month:</b> ' +
str(for_a_month.frequency) + ' | ' +
str(for_a_month.dominance) + '%')
self.year.setText(for_a_year.character)
self.yearLabel.setText('<b>Year:</b> ' +
str(for_a_year.frequency) + ' | ' +
str(for_a_year.dominance) + '%')
self.kanji_tooltip(self.day)
self.kanji_tooltip(self.week)
self.kanji_tooltip(self.month)
self.kanji_tooltip(self.year)
if self.stats.isVisible():
self.stats.update_stat_info()
self.stats.refresh_plot()
self.hide_message()
else:
self.show_message_then_hide(results['message'])
self.hide_progress()
def pretty_font(self):
pass
def update_alg(self):
self.al.set_active(str(self.methodCombo.currentText()))
def init_backend(self):
self.al = RandomMess()
self.update_alg()
def auth_task(self):
self.auth_thread = AuthorizationTask(self.al)
self.auth_thread.done.connect(self.auth_complete)
#self.auth_thread.run()
# IT DOESN't work on windows as it should!
self.auth_thread.start()
self.show_progress('Authorizing on RNG services...')
def auth_complete(self, success):
self.hide_message()
self.hide_progress()
if success:
self.show_message_then_hide("Successfully authenticated!", False)
else:
self.show_message_then_hide("Sorry, could not authenticate.")
def show_message_then_hide(self, message, error=True):
if error:
self.statusMessage.setStyleSheet(WARNING_STYLE)
else:
self.statusMessage.setStyleSheet(NOTE_STYLE)
self.statusMessage.setText(message)
self.statusMessage.show()
QTimer.singleShot(MESSAGE_TIMEOUT, self.hide_message)
def show_progress(self, message):
self.statusMessage.setStyleSheet(NOTE_STYLE)
self.statusMessage.setText(message)
self.statusMessage.show()
self.progressBar.show()
def hide_message(self):
self.statusMessage.setText('')
self.statusMessage.hide()
def hide_progress(self):
self.progressBar.hide()
def toggle_kanji_info(self, label, info):
label.setToolTip(info.info())
def kanji_tooltip(self, label):
found = JDIC.search(label.text())
if found:
label.setToolTip(found.info())
else:
label.setToolTip('No such kanji in kanjidic2!')
def kanji_info(self, kanji):
pass
def app_help(self):
self.aboutBox.show()
#### Utility events ####
def resizeEvent(self, QResizeEvent):
self.updateStatsPosition()
self.updateStatsSize()
def moveEvent(self, QMoveEvent):
self.updateStatsPosition()
self.updateStatsSize()
def updateStatsPosition(self):
self.stats.move(self.x() + self.width() + 20, self.y())
def updateStatsSize(self):
self.stats.resize(QSize(self.stats.width(), self.height()))
class MainWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.setWindowTitle('%s %s' % (QApplication.applicationName(), QApplication.applicationVersion()));
self.config = ConfigHandler(os.path.join(os.path.expanduser('~'), '.pywv/pywv.cfg'), self)
self.setStyle(QStyleFactory.create(self.config.loadStyle()))
if self.config.loadStyleSheet():
self.setStyleSheet(self.config.loadStyleSheet())
else:
self.setStyleSheet("* {}") # without any stylesheet, windowstyles won't apply
self.setDockOptions(QMainWindow.AnimatedDocks | QMainWindow.AllowNestedDocks | QMainWindow.AllowTabbedDocks | QMainWindow.VerticalTabs);
# self.dummy = QWidget(self)
self.setCentralWidget(QWidget(self))
self.pBar = QProgressBar(self)
self.pBar.setRange(0, self.config.loadReloadInterval())
self.pBar.setFormat("%v Sekunden")
if not self.config.loadAutoload():
self.pBar.hide()
self.statusBar = QStatusBar(self)
self.setStatusBar(self.statusBar)
self.statusBar.addWidget(self.pBar)
self.reloadTimer = QTimer(self);
self.reloadTimer.setInterval(self.config.loadReloadInterval() * 1000)
self.connect(self.reloadTimer, SIGNAL('timeout()'), self.reload_)
if self.config.loadAutoload():
self.reloadTimer.start()
self.autoloadStatusTimer = QTimer(self)
self.autoloadStatusTimer.setInterval(1000) # 1 sec
self.connect(self.autoloadStatusTimer, SIGNAL('timeout()'), self.onAutoloadStatus)
self.autoloadStatusTimer.start()
self.mAction = self.menuBar().addMenu(self.tr("&Action"))
self.mAction.addAction(self.tr("&update"), self.reload_, QKeySequence('F5'))
self.mAction.addAction(self.tr("e&xit"), self.onExit, 'Ctrl+Q')
self.mStyle = QMenu(self.tr("&Style"), self)
for s in list(QStyleFactory.keys()):# // fill in all available Styles
self.mStyle.addAction(s)
self.connect(self.mStyle, SIGNAL('triggered(QAction*)'), self.onStyleMenu)
self.mOption = self.menuBar().addMenu(self.tr("&Options"))
self.mOption.addAction(self.tr("reloadinterval") , self.onReloadTime , 'F8')
self.mOption.addAction(self.tr("manage links") , self.onNewLink , 'F6')
self.mOption.addSeparator()
self.ontopAction = QAction(self.tr("always on &top") , self)
self.showTrayAction = QAction(self.tr("show tray &icon") , self)
self.closeToTrayAction = QAction(self.tr("close to &tray") , self)
self.autoloadAction = QAction(self.tr("auto&load") , self)
self.ontopAction.setCheckable(True)
self.showTrayAction.setCheckable(True)
self.closeToTrayAction.setCheckable(True)
self.autoloadAction.setCheckable(True)
self.showTrayAction.setChecked (self.config.loadShowTray() )
self.ontopAction.setChecked (self.config.loadOntop() )
self.closeToTrayAction.setChecked(self.config.loadCloseToTray())
self.autoloadAction.setChecked (self.config.loadAutoload() )
self.connect(self.ontopAction , SIGNAL('toggled(bool)') , self.onOntopAction)
self.connect(self.showTrayAction , SIGNAL('toggled(bool)') , self.onShowTrayAction)
self.connect(self.closeToTrayAction , SIGNAL('toggled(bool)') , self.onCloseToTrayAction)
self.connect(self.autoloadAction , SIGNAL('toggled(bool)') , self.onAutoloadAction)
self.mOption.addAction(self.ontopAction)
self.mOption.addAction(self.showTrayAction)
self.mOption.addAction(self.closeToTrayAction)
self.mOption.addAction(self.autoloadAction)
self.mOption.addSeparator()
self.mOption.addMenu(self.mStyle)
self.trayIcon = QSystemTrayIcon(QIcon(':/appicon'), self);
self.trayMgr = TrayManager(self.config, self.trayIcon)
self.connect(self.trayIcon, SIGNAL('activated(QSystemTrayIcon::ActivationReason)'), self.onTrayIcon)
if self.config.loadShowTray(): self.trayIcon.show()
self.trayIconMenu = QMenu()
self.trayIconMenu.addAction(self.tr("e&xit"), self.onExit)
self.trayIcon.setContextMenu(self.trayIconMenu)
self.mAbout = self.menuBar().addMenu(self.tr("&about"))
self.mAbout.addAction(QApplication.applicationName(), self.onAboutAppAction)
self.mAbout.addAction("Qt", self.onAboutQtAction)
self.createWidgets()
self.resize(self.config.loadWindowSize())
self.restoreState(self.config.loadWindowState())
if self.config.loadIsVisible():
self.show()
self.reload_()
def __del__(self):
self.config.saveWindowState(self.saveState())
def createSingleWidget(self, name):
# print 'crt', name, type(name), '\n', self.widgets
# print 'crt', name, type(name)
links = self.config.loadLinks()
if links[name]['type'] == 'generic':
self.widgets[name] = GenericWidget(name, self.config, self)
else:
pluginsAvail = classdirPlugins().all_()
for plugin in pluginsAvail:
if links[name]['type'] == plugin['class']:
pluginClass = plugin['class']
break
else:
continue
exec('self.widgets[name] = %s(name, self.config, self)' % pluginClass)
# print(('loaded plugin', self.widgets[name]))
self.addDockWidget(0x4, self.widgets[name])
self.widgets[name].reload_()
def delWidget(self, name):
#print 'del', name, type(name), '\n', self.widgets
self.removeDockWidget(self.widgets[name])
self.widgets[name].deleteLater()
self.widgets[name] = None
del self.widgets[name]
def createWidgets(self):
self.widgets = {}
for name in self.config.loadLinks():
self.createSingleWidget(name)
@pyqtSlot()
def onExit(self):
self.config.saveWindowSize(self.size())
QApplication.exit();
def closeEvent(self, event):
self.config.saveWindowSize(self.size())
# QApplication.exit()
# tray is visible -> close to tray
# else close app
if self.trayIcon.isVisible():
event.accept()
else:
QApplication.exit()
return
# if close-to-tray is set, do so
if self.config.loadCloseToTray():
event.accept()
else:
QApplication.exit()
return;
# save this state
if self.trayIcon.isVisible(): self.config.saveIsVisible(False)
else: self.config.saveIsVisible(True);
@pyqtSlot()
def reload_(self):
for name in self.widgets:
self.widgets[name].reload_()
self.pBar.setValue(self.config.loadReloadInterval())
self.reloadTimer.start(self.config.loadReloadInterval()*1000)
@pyqtSlot()
def onAutoloadStatus(self):
self.pBar.setValue(self.pBar.value()-1)
# print([idx for idx in self.widgets])
def onStyleMenu(self, a):
QApplication.setStyle(QStyleFactory.create(a.text()))
self.setStyle(QStyleFactory.create(a.text()))
self.config.saveStyle(a.text())
def onReloadTime(self):
ok = False
value, ok = QInputDialog.getInteger(self,
self.tr("reloadinterval"), # title
self.tr("insert time in s"), # text
self.config.loadReloadInterval(), # default
10, # minimum
86400, # maximum (at least once a day)
1, # step
)
if ok:
self.config.saveReloadInterval(value)
self.pBar.setRange(0,self.config.loadReloadInterval())
self.reload_()
def onAutoloadAction(self, b):
if b:
self.reloadTimer.start()
self.pBar.show()
self.reload_()
else:
self.reloadTimer.stop()
self.pBar.hide()
self.config.saveAutoload(b)
def onNewLink(self):
inp = LinkInput(self.config, self)
if inp.exec_():
# sync active widgets
for name in inp.modifiedWidgets():
if name in self.widgets:
self.delWidget(name)
self.createSingleWidget(name)
else:
self.createSingleWidget(name)
# remove deleted
# for name in self.widgets: print 'shown', name
# for name in self.config.loadLinks(): print 'conf', name
todel = []
for name in self.widgets:
if name not in self.config.loadLinks():
todel.append(name)
for widget in todel:
self.delWidget(widget)
def onOntopAction(self, b):
if b: self.setWindowFlags(Qt.Dialog | Qt.WindowStaysOnTopHint)
else: self.setWindowFlags(Qt.Dialog)
self.setWindowIcon(QIcon(':/appicon'))
self.show();
self.config.saveOntop(b)
def onShowTrayAction(self, b):
if b: self.trayIcon.show()
else: self.trayIcon.hide()
self.config.saveShowTray(b)
def onCloseToTrayAction(self, b):
self.config.saveCloseToTray(b)
def onTrayIcon(self, reason):
if reason == QSystemTrayIcon.Trigger:
if(self.isVisible()):
self.config.saveWindowSize(self.size())
self.hide()
self.config.saveIsVisible(False)
else:
self.show()
self.resize(self.config.loadWindowSize())
self.config.saveIsVisible(True)
def onAboutAppAction(self):
QMessageBox.about(self, self.tr("&about"), self.tr("name %1 version %2").arg(QApplication.applicationName()).arg(QApplication.applicationVersion()))
def onAboutQtAction(self):
QMessageBox.aboutQt(self, self.tr("&about"))
class FeedLol(QMainWindow):
def __init__(self, parent = None):
QMainWindow.__init__(self, parent)
self.setWindowTitle("FeedLol")
self.aboutAction = QAction(QIcon("data/icons/help-about.svg"), "&About FeedLol...", self)
self.connect(self.aboutAction, SIGNAL("triggered()"), self.slotAbout)
self.reloadAction = QAction(QIcon("data/icons/view-refresh.svg"), "&Reload", self)
self.reloadAction.setShortcut(QKeySequence.Refresh)
self.homeAction = QAction(QIcon("data/icons/go-home.svg"), "Go &Home", self)
self.homeAction.setShortcut("Alt+Home")
self.userAction = QAction(QIcon("data/icons/user-identity.svg"), "&Me", self)
self.userAction.setShortcut("Ctrl+M")
self.logoutAction = QAction(QIcon("data/icons/dialog-close.svg"), "Log&out", self)
self.logoutAction.setShortcut(QKeySequence.Close)
self.settingsAction = QAction(QIcon("data/icons/configure.svg"), "&Preferences...", self)
self.connect(self.settingsAction, SIGNAL("triggered()"), self.slotSettings)
self.toolbar = QToolBar("Toolbar", self)
self.toolbar.setObjectName("toolbar")
self.toolbar.addAction(self.homeAction)
self.toolbar.addAction(self.userAction)
self.toolbar.addAction(self.reloadAction)
self.toolbar.addSeparator()
self.toolbar.addAction(self.logoutAction)
self.toolbar.addSeparator()
self.toolbar.addAction(self.settingsAction)
self.toolbar.addAction(self.aboutAction)
self.addToolBar(self.toolbar)
self.loadStatus = QProgressBar(self)
self.loadStatus.setRange(0, 100)
self.loadStatus.setMaximumWidth(200)
self.loadStatus.setTextVisible(False)
self.loadStatus.hide()
self.statusBar().addPermanentWidget(self.loadStatus)
self.feedView = FeedView(self)
self.setCentralWidget(self.feedView)
self.connect(self.feedView, SIGNAL("titleChanged(const QString&)"), self.slotSetTitle)
self.connect(self.feedView, SIGNAL("statusBarMessage(const QString&)"), self.statusBar(), SLOT("showMessage(const QString&)"))
self.connect(self.feedView, SIGNAL("loadStarted()"), self.loadStart)
self.connect(self.feedView, SIGNAL("loadFinished(bool)"), self.loadStop)
self.connect(self.feedView, SIGNAL("loadProgress(int)"), self.loadProgress)
self.connect(self.reloadAction, SIGNAL("triggered()"), self.feedView.reload)
self.connect(self.homeAction, SIGNAL("triggered()"), self.feedView.goHome)
self.connect(self.userAction, SIGNAL("triggered()"), self.feedView.goToUserPage)
self.connect(self.logoutAction, SIGNAL("triggered()"), self.feedView.logout)
self.connect(self.feedView.page(), SIGNAL("linkHovered(const QString&, const QString&, const QString&)"), self.linkHovered)
self.settingsDialog = SettingsDialog(self.feedView, self)
settings = QSettings()
if settings.contains("proxy/type"):
proxy = QNetworkProxy()
proxyType = settings.value("proxy/type").toInt()[0]
proxy.setType( (proxyType == 2) and QNetworkProxy.Socks5Proxy or ( (proxyType == 1) and QNetworkProxy.HttpProxy or QNetworkProxy.NoProxy ) )
if proxy.type() != QNetworkProxy.NoProxy:
proxy.setHostName(settings.value("proxy/host").toString())
proxy.setPort(settings.value("proxy/port").toInt()[0])
if settings.value("proxy/user").toString():
proxy.setUser(settings.value("proxy/user").toString())
proxy.setPassword(settings.value("proxy/password").toString())
QNetworkProxy.setApplicationProxy(proxy)
if settings.contains("mainWindow/geometry"):
self.restoreGeometry(settings.value("mainWindow/geometry").toByteArray())
else:
self.resize(320,480)
if settings.contains("mainWindow/state"):
self.restoreState(settings.value("mainWindow/state").toByteArray())
self.feedView.goHome()
def saveConfig(self):
settings = QSettings()
settings.setValue("mainWindow/geometry", QVariant(self.saveGeometry()))
settings.setValue("mainWindow/state", QVariant(self.saveState()))
session = self.feedView.siteServer.session
from cPickle import dumps
session = dumps(session)
settings.setValue("session", QVariant(session))
proxy = QNetworkProxy.applicationProxy()
proxyType = (proxy.type() == QNetworkProxy.Socks5Proxy) and 2 or ( (proxy.type() == QNetworkProxy.HttpProxy) and 1 or 0 )
settings.setValue("proxy/type", QVariant(proxyType))
settings.setValue("proxy/host", QVariant(proxy.hostName()))
settings.setValue("proxy/port", QVariant(proxy.port()))
settings.setValue("proxy/user", QVariant(proxy.user()))
settings.setValue("proxy/password", QVariant(proxy.password()))
def slotAbout(self):
from PyQt4.QtGui import QMessageBox
QMessageBox.about(self, "FeedLol", "<h2>FeedLol 0.1</h2><p>Copyright © 2008 <a href=\"mailto:[email protected]\">Bodil Stokke</a></p>")
def slotSettings(self):
self.settingsDialog.updateSettings()
if self.settingsDialog.exec_() == QDialog.Accepted:
self.settingsDialog.applySettings()
def slotSetTitle(self, title):
self.setWindowTitle("FeedLol: " + title)
def loadStart(self):
self.loadStatus.show()
def loadStop(self):
self.loadStatus.hide()
def loadProgress(self, progress):
self.loadStatus.setValue(progress)
def linkHovered(self, url, title, text):
if url and QUrl(url).scheme() != "chrome":
self.statusBar().showMessage(url)
else:
self.statusBar().clearMessage()
class WidgetMEncoderConcatExtResol(QDialog):
def __init__(self, cheminVideoEntre, valeurNum=0, cheminMEncoder=None):
QDialog.__init__(self)
# === Paramètres généraux ===#
self.repTampon = EkdConfig.getTempDir() + os.sep
# Répertoire de sauvegarde ds le rep tampon
self.rep_video_ext_resol = self.repTampon + "video_extension_resol" + os.sep
# Uniquement pour Linux et MacOSX
if os.name in ["posix", "mac"] or not cheminMEncoder:
self.cheminMEncoder = u"mencoder"
# Uniquement pour windows
elif os.name == "nt" and cheminMEncoder:
self.cheminMEncoder = unicode(cheminMEncoder)
# chemin(s) des vidéos chargées
self.cheminVideoEntre = cheminVideoEntre
# valeur de la boite de spin pour l'encodage
self.valeurNum = valeurNum
self.fichiers = [os.path.basename(parc) for parc in self.cheminVideoEntre]
# Appel de la fonction lanceur
self.lanceur()
def lanceur(self):
# Au cas où le répertoire existait déjà et qu'il n'était pas vide -> purge (simple précausion)
# Cela est indispensable ici car si on relance le montage sans avoir purgé le répertoire, le
# montage se fera avec les anciennes vidéos mélangées aux nouvelles (donc gros problème !)
if os.path.isdir(self.rep_video_ext_resol) is True:
for toutRepCompo in glob.glob(self.rep_video_ext_resol + "*.*"):
os.remove(toutRepCompo)
infoConfirm = QMessageBox.information(
self,
"Message",
_(
u"<p>Vous voyez cette boîte de dialogue car vous vous apprêtez à concaténer des vidéos ayant des extensions différentes (c'est à dire préalablement encodées dans des codecs différents).</p><p><b>Sachez malgré tout que la vidéo finale</b> (résultat final de la concaténation), <b>sera encodée en Motion JPEG (extension .avi)</b>.</p><p>Sachez de même que vous pouvez encoder des vidéos ayant des résolutions différentes (largeur x hauteur), <b>la taille de la vidéo finale sera celle de la vidéo la plus répandue dans les vidéos chargées</b> (si vous avez chargé des vidéos avec des dimensions complètement différentes, la taille sélectionnée sera celle de la première vidéo du lot).</p><p><b>Si au moins une des vidéos du lot ne possède pas de canal audio</b> (c'est à dire qu'elle ne comporte pas de son), <b>la concaténation finale se fera sans le son</b>.</p><p><b>Voulez-vous continuer ?</b> (si vous répondez non le traitement n'aura pas lieu correctement)."
),
QMessageBox.Yes,
QMessageBox.No,
)
if infoConfirm == QMessageBox.No:
return
elif infoConfirm == QMessageBox.Yes:
self.appliquer()
@pyqtSignature("")
def appliquer(self):
self.labelAttente = QLabel()
self.labelAttente.setText(
_(
u"<p><b>Encodage des vidéos en Motion JPEG</b></p><p>Attendez la fin du calcul s'il vous plaît (soyez patient !) ... traitement des fichiers: </p><p><b>%s</b></p>"
% "<br>".join(self.cheminVideoEntre)
)
)
self.bout_annuler = QPushButton(_(u"Annuler"))
self.progress = QProgressBar()
self.progress.setMaximum(100)
self.progress.setValue(0)
vbox = QVBoxLayout()
vbox.addWidget(self.labelAttente)
hbox = QHBoxLayout()
hbox.addWidget(self.progress)
hbox.addWidget(self.bout_annuler)
vbox.addLayout(hbox)
self.setLayout(vbox)
self.connect(self.bout_annuler, SIGNAL("clicked()"), SLOT("close()"))
self.th = MencoderConcatThread(self.cheminVideoEntre, self.valeurNum, self.cheminMEncoder) # , parent=None) #
# Connections pour l'appel et l'application du pourcentage dans la barre
# ... essai de récup du fichier chargé ... pour eventuellement pouvoir
# afficher le fichiers en cours dans la barre (au dessus de la barre
# elle même --> mais pas réussi à importer fichier_1 pour pouvoir
# l'afficher à la place de self.fichiers dans self.progress
self.th.connect(self.th, SIGNAL("increment(int)"), self.affichPourcent)
self.th.connect(self.th, SIGNAL("travail_avec_fichier"), self.fichierDeTravail)
self.progress.connect(self.progress, SIGNAL("canceled()"), self.th, SLOT("cancel()"))
self.progress.show()
self.th.start()
# On ajoute un parametre à la méthode
def affichPourcent(self, pourcent):
self.progress.setValue(pourcent)
QApplication.processEvents()
# Quand la progression arrive à 100%, la fenêtre
# contenant la QProgressBar se ferme
if pourcent == 100:
self.th.wait()
self.close()
# De même, on ajoute un parametre à la méthode
def fichierDeTravail(self, fichier_1):
debug(u"Fichier chargé: %s" % fichier_1)
class BrowserWindow(QMainWindow):
def retranslateUi(self):
self.setWindowTitle(
QApplication.translate("self", "self", None,
QApplication.UnicodeUTF8))
self.menuFile.setTitle(
QApplication.translate("self", "&File", None,
QApplication.UnicodeUTF8))
self.menuView.setTitle(
QApplication.translate("self", "&View", None,
QApplication.UnicodeUTF8))
self.menuEdit.setTitle(
QApplication.translate("self", "&Edit", None,
QApplication.UnicodeUTF8))
self.menuHelp.setTitle(
QApplication.translate("self", "&Help", None,
QApplication.UnicodeUTF8))
self.toolBar.setWindowTitle(
QApplication.translate("self", "toolBar", None,
QApplication.UnicodeUTF8))
self.actionHome.setText(
QApplication.translate("self", "&Home", None,
QApplication.UnicodeUTF8))
self.actionHome.setToolTip(
QApplication.translate("self", "Go Home", None,
QApplication.UnicodeUTF8))
self.actionShowMenu.setText(
QApplication.translate("self", "Show &Menu", None,
QApplication.UnicodeUTF8))
self.actionShowToolbar.setText(
QApplication.translate("self", "Show &Toolbar", None,
QApplication.UnicodeUTF8))
self.actionClose.setText(
QApplication.translate("self", "&Close", None,
QApplication.UnicodeUTF8))
self.actionModifyWebapp.setText(
QApplication.translate("self", "Modify &Webapp", None,
QApplication.UnicodeUTF8))
self.actionEditPreferences.setText(
QApplication.translate("self", "Edit &Preferences", None,
QApplication.UnicodeUTF8))
self.actionPrint.setText(
QApplication.translate("self", "&Print", None,
QApplication.UnicodeUTF8))
self.actionAbout.setText(
QApplication.translate("self", "&About", None,
QApplication.UnicodeUTF8))
def __init__(self, appid, base, name):
super(BrowserWindow, self).__init__()
self.appid = appid
self.name = name
self.original_name = name
self.base = base
# Main widgets
self.centralwidget = QWidget(self)
self.gridLayout_2 = QGridLayout(self.centralwidget)
self.setCentralWidget(self.centralwidget)
self.urlLineEdit = QLineEdit(self)
self.progressBar = QProgressBar(self)
# Custom webview
self.page = LocalWebPage()
self.page.setFeaturePermission(self.page.mainFrame(),
LocalWebPage.Notifications,
LocalWebPage.PermissionGrantedByUser)
self.webkitNotifications = WebkitNotifications(self)
self.webViewMain = LocalWebView(self.centralwidget)
self.webViewMain.setPage(self.page)
self.gridLayout_2.addWidget(self.webViewMain, 0, 0, 1, 1)
self.webViewMain.setContentsMargins(0, 0, 0, 0)
self.gridLayout_2.setContentsMargins(0, 0, 0, 0)
self.menubar = QMenuBar(self)
self.menuFile = QMenu(self.menubar)
self.menuView = QMenu(self.menubar)
self.menuEdit = QMenu(self.menubar)
self.menuHelp = QMenu(self.menubar)
self.setMenuBar(self.menubar)
self.statusbar = QStatusBar(self)
self.setStatusBar(self.statusbar)
self.toolBar = QToolBar(self)
self.toolBar.setMovable(False)
self.toolBar.setFloatable(False)
self.addToolBar(Qt.TopToolBarArea, self.toolBar)
# Create actions
self.actionOpenLinkInNewWindow = self.page.action(
self.page.OpenLinkInNewWindow)
self.actionOpenLinkInNewWindow.setText(
tr('BrowserWindow', 'Open in &Browser'))
self.actionBack = self.page.action(self.page.Back)
self.actionForward = self.page.action(self.page.Forward)
self.actionStop = self.page.action(self.page.Stop)
self.actionReload = self.page.action(self.page.Reload)
self.actionHome = QAction(self)
self.actionShowMenu = QAction(self)
self.actionShowMenu.setCheckable(True)
self.actionShowToolbar = QAction(self)
self.actionShowToolbar.setCheckable(True)
self.actionClose = QAction(self)
self.actionModifyWebapp = QAction(self)
self.actionEditPreferences = QAction(self)
self.actionPrint = QAction(self)
self.actionSaveLink = self.page.action(self.page.DownloadLinkToDisk)
self.actionSaveLink.setEnabled(False)
self.actionAbout = QAction(self)
# Populate menu and toolbars
self.menuFile.addAction(self.actionHome)
self.menuFile.addAction(self.actionBack)
self.menuFile.addAction(self.actionForward)
self.menuFile.addAction(self.actionStop)
self.menuFile.addAction(self.actionReload)
self.menuFile.addSeparator()
self.menuFile.addAction(self.actionPrint)
self.menuFile.addSeparator()
self.menuFile.addAction(self.actionClose)
self.menuView.addAction(self.actionShowMenu)
self.menuView.addAction(self.actionShowToolbar)
self.menuView.addSeparator()
self.menuEdit.addAction(self.actionModifyWebapp)
#self.menuEdit.addAction(self.actionEditPreferences)
self.menuHelp.addAction(self.actionAbout)
self.menubar.addAction(self.menuFile.menuAction())
self.menubar.addAction(self.menuEdit.menuAction())
self.menubar.addAction(self.menuView.menuAction())
self.menubar.addAction(self.menuHelp.menuAction())
self.toolBar.addAction(self.actionHome)
self.toolBar.addAction(self.actionBack)
self.toolBar.addAction(self.actionForward)
self.toolBar.addWidget(self.urlLineEdit)
self.toolBar.addAction(self.actionStop)
self.toolBar.addAction(self.actionReload)
self.retranslateUi()
QMetaObject.connectSlotsByName(self)
self.setWindowTitle(self.name)
# Set up cookie jar that persists sessions
self.cookieJar = PersistableCookieJar(self, identifier=self.appid)
self.cookieJar.load()
self.webViewMain.page().networkAccessManager().setCookieJar(
self.cookieJar)
# Set up link delegation so that external links open in web browser.
self.webViewMain.page().setLinkDelegationPolicy(
QWebPage.DelegateExternalLinks)
self.desktopEntry = desktop.getEntry(self.appid)
# Set icons for actions; this can't be done in the designer, AFAICT
self.actionHome.setIcon(QIcon.fromTheme('go-home'))
self.actionAbout.setIcon(QIcon.fromTheme('help-about'))
# Set up shortcuts
self.actionStop.setShortcut(Qt.Key_Escape)
self.actionBack.setShortcut(QKeySequence.Back)
self.actionForward.setShortcut(QKeySequence.Forward)
self.actionReload.setShortcut(QKeySequence.Refresh)
self.actionHome.setShortcut('Ctrl+Home')
self.actionShowMenu.setShortcut('Ctrl+m')
self.actionShowToolbar.setShortcut('Ctrl+t')
self.actionPrint.setShortcut(QKeySequence.Print)
self.backShortcut = QShortcut(self)
self.backShortcut.setKey(Qt.Key_Back)
self.backShortcut.activated.connect(self.webViewMain.back)
self.forwardShortcut = QShortcut(self)
self.forwardShortcut.setKey(Qt.Key_Forward)
self.forwardShortcut.activated.connect(self.webViewMain.forward)
# Set up context menu
self.webViewMain.setContextMenuPolicy(Qt.CustomContextMenu)
self.webViewMain.customContextMenuRequested.connect(self.showMenu)
# Setup statusbar and toolbar
for c in self.statusBar().children()[0].children():
c.removeWidget(c)
self.statusBar().addPermanentWidget(self.progressBar, 1)
self.actionShowToolbar.setChecked(True)
self.actionShowMenu.setChecked(True)
# Icon
if self.desktopEntry.hasKey('Icon'):
self.icon = QIcon(self.desktopEntry.get('Icon'))
self.setWindowIcon(self.icon)
else:
self.webViewMain.iconChanged.connect(self.setWindowIcon)
# Set up events
if self.desktopEntry.get('X-%s-menu-enabled' % APP_NAME) == '0':
self.actionShowMenu.setChecked(False)
else:
self.actionShowMenu.setChecked(True)
if self.desktopEntry.get('X-%s-toolbar-enabled' % APP_NAME) == '0':
self.actionShowToolbar.setChecked(False)
else:
self.actionShowToolbar.setChecked(True)
self.webViewMain.linkClicked.connect(self._onLinkClick)
self.webViewMain.titleChanged.connect(self.setWindowTitle)
self.webViewMain.loadProgress.connect(self._setLoadingStatus)
self.webViewMain.urlChanged.connect(
lambda x: self.urlLineEdit.setText(x.toString()))
self.page.printRequested.connect(self._onPrint)
self.page.loadFinished.connect(self._loadingFinished)
self.actionHome.triggered.connect(
lambda x: self.webViewMain.load(QUrl(self.base)))
self.actionClose.triggered.connect(self.close)
self.actionPrint.triggered.connect(self._onPrint)
self.urlLineEdit.returnPressed.connect(self._onUrlEdit)
self.actionShowToolbar.triggered.connect(self._onShowToolbar)
self.actionShowMenu.triggered.connect(self._onShowMenu)
self.actionAbout.triggered.connect(lambda x: about.show(self))
self.actionModifyWebapp.triggered.connect(self._onModify)
self._onShowMenu()
self._onShowToolbar()
try:
self.resize(int(self.desktopEntry.getWindowWidth()),
int(self.desktopEntry.getWindowHeight()))
except (ValueError, TypeError):
self.resize(800, 600)
# Load first page
self.webViewMain.load(QUrl(base))
self.editor = SiteEditorWindow(self.desktopEntry, isNew=False)
def _onModify(self):
self.editor.show()
def closeEvent(self, qCloseEvent):
self.desktopEntry.setWindowWidth(self.width())
self.desktopEntry.setWindowHeight(self.height())
self.desktopEntry.write()
def _onPrint(self):
printer = QPrinter()
dialog = QPrintDialog(printer, self)
if dialog.exec_() != QDialog.Accepted:
return
self.page.mainFrame().print_(printer)
def _loadingFinished(self):
# TODO: Add user scripts here
# TODO: Add user styles here
# Override window.webkitNotifications
self.page.mainFrame().addToJavaScriptWindowObject(
"_x_webplier_webkitNotifications", self.webkitNotifications)
self.page.mainFrame().evaluateJavaScript(
WebkitNotifications.JAVASCRIPT)
def _setLoadingStatus(self, value):
if value < 100:
self.progressBar.setValue(value)
self.progressBar.show()
self.statusBar().show()
self.actionReload.setVisible(False)
self.actionStop.setVisible(True)
else:
self.page.setFeaturePermission(
self.page.mainFrame(), LocalWebPage.Notifications,
LocalWebPage.PermissionGrantedByUser)
self.progressBar.hide()
self.statusBar().hide()
self.actionReload.setVisible(True)
self.actionStop.setVisible(False)
def _onUrlEdit(self):
url = unicode(self.urlLineEdit.text())
qurl = QUrl(url)
if not qurl.scheme():
qurl.setScheme('http')
self.webViewMain.load(qurl)
def _onLinkClick(self, qurl):
url = unicode(qurl.toString())
if not unicode(url).startswith(self.base):
webbrowser.open(url, 1)
else:
self.webViewMain.load(qurl)
def _onShowToolbar(self):
if self.actionShowToolbar.isChecked():
self.toolBar.show()
self.desktopEntry.set('X-%s-toolbar-enabled' % APP_NAME, '1')
else:
self.toolBar.hide()
self.desktopEntry.set('X-%s-toolbar-enabled' % APP_NAME, '0')
def _onShowMenu(self):
if self.actionShowMenu.isChecked():
self.menubar.show()
self.desktopEntry.set('X-%s-menu-enabled' % APP_NAME, '1')
else:
self.menubar.hide()
self.desktopEntry.set('X-%s-menu-enabled' % APP_NAME, '0')
def showMenu(self, point):
m = self.webViewMain.page().createStandardContextMenu()
# TODO: Make this less awful and fragile
for a in m.actions():
if a == self.actionSaveLink:
m.removeAction(a)
m.addSeparator()
m.addAction(self.actionShowMenu)
m.addAction(self.actionShowToolbar)
globalpos = self.mapToParent(point)
m.exec_(globalpos)
class LabelAssistDialog(QDialog):
"""
A simple UI for showing bookmarks and navigating to them.
FIXME: For now, this window is tied to a particular lane.
If your project has more than one lane, then each one
will have it's own bookmark window, which is kinda dumb.
"""
def __init__(self, parent, topLevelOperatorView):
super(LabelAssistDialog, self).__init__(parent)
# Create thread router to populate table on main thread
self.threadRouter = ThreadRouter(self)
# Set object classification operator view
self.topLevelOperatorView = topLevelOperatorView
self.setWindowTitle("Label Assist")
self.setMinimumWidth(500)
self.setMinimumHeight(700)
layout = QGridLayout()
layout.setContentsMargins(10, 10, 10, 10)
# Show variable importance table
rows = 0
columns = 4
self.table = QTableWidget(rows, columns)
self.table.setHorizontalHeaderLabels(
['Frame', 'Max Area', 'Min Area', 'Labels'])
self.table.verticalHeader().setVisible(False)
# Select full row on-click and call capture double click
self.table.setSelectionBehavior(QTableView.SelectRows)
self.table.doubleClicked.connect(self._captureDoubleClick)
layout.addWidget(self.table, 1, 0, 3, 2)
# Create progress bar
self.progressBar = QProgressBar()
self.progressBar.setMinimum(0)
self.progressBar.setMaximum(0)
self.progressBar.hide()
layout.addWidget(self.progressBar, 4, 0, 1, 2)
# Create button to populate table
self.computeButton = QPushButton('Compute object info')
self.computeButton.clicked.connect(self._triggerTableUpdate)
layout.addWidget(self.computeButton, 5, 0)
# Create close button
closeButton = QPushButton('Close')
closeButton.clicked.connect(self.close)
layout.addWidget(closeButton, 5, 1)
# Set dialog layout
self.setLayout(layout)
def _triggerTableUpdate(self):
# Check that object area is included in selected features
featureNames = self.topLevelOperatorView.SelectedFeatures.value
if 'Standard Object Features' not in featureNames or 'Count' not in featureNames[
'Standard Object Features']:
box = QMessageBox(
QMessageBox.Warning, 'Warning',
'Object area is not a selected feature. Please select this feature on: \"Standard Object Features > Shape > Size in pixels\"',
QMessageBox.NoButton, self)
box.show()
return
# Clear table
self.table.clearContents()
self.table.setRowCount(0)
self.table.setSortingEnabled(False)
self.progressBar.show()
self.computeButton.setEnabled(False)
# Compute object features and number of labels per frame
def compute_features():
features = self.topLevelOperatorView.ObjectFeatures([]).wait()
labels = self.topLevelOperatorView.LabelInputs([]).wait()
return features, labels
req = Request(compute_features)
req.notify_finished(self._populateTable)
req.submit()
@threadRouted
def _populateTable(self, features_and_labels):
features, labels = features_and_labels
self.progressBar.hide()
self.computeButton.setEnabled(True)
for frame, objectFeatures in features.iteritems():
# Insert row
rowNum = self.table.rowCount()
self.table.insertRow(self.table.rowCount())
# Get max and min object areas
areas = objectFeatures['Standard Object Features']['Count']
maxObjArea = numpy.max(areas[numpy.nonzero(areas)])
minObjArea = numpy.min(areas[numpy.nonzero(areas)])
# Get number of labeled objects
labelNum = numpy.count_nonzero(labels[frame])
# Load fram number
item = QTableWidgetItem(str(frame))
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.table.setItem(rowNum, 0, item)
# Load max object areas
item = QTableWidgetItemWithFloatSorting(
str("{: .02f}".format(maxObjArea)))
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.table.setItem(rowNum, 1, item)
# Load min object areas
item = QTableWidgetItemWithFloatSorting(
str("{: .02f}".format(minObjArea)))
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.table.setItem(rowNum, 2, item)
# Load label numbers
item = QTableWidgetItemWithFloatSorting(
str("{: .01f}".format(labelNum)))
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.table.setItem(rowNum, 3, item)
# Resize column size to fit dialog size
self.table.horizontalHeader().setResizeMode(QHeaderView.Stretch)
# Sort by max object area
self.table.setSortingEnabled(True)
self.table.sortByColumn(1)
def _captureDoubleClick(self):
# Navigate to selected frame
index = self.table.selectedIndexes()[0]
frameStr = self.table.model().data(index).toString()
if frameStr:
frameNum = int(frameStr)
self.parent().editor.posModel.time = frameNum
class WidgetFFmpegAvchd(QDialog):
### Ajout (le 13/08/2010) de spec_sortie_DNxHD et son_sortie_DNxHD #################
def __init__(self, cheminVideoEntre, enregistrerSortie, codec_sortie, reso_largeur_sortie, reso_hauteur_sortie, nbreImgSec_sortie, qualite_sortie, spec_sortie_DNxHD, son_sortie_DNxHD, parent, cheminFFmpeg=None):
QDialog.__init__(self)
#=== Paramètres généraux ===#
# Uniquement pour Linux et MacOSX
if os.name in ['posix', 'mac']: self.cheminFFmpeg = "ffmpeg"
# Uniquement pour windows
elif os.name == 'nt': self.cheminFFmpeg = "ffmpeg.exe"
# chemin(s) des vidéos chargées
self.cheminVideoEntre = cheminVideoEntre
# Chemin + nom de fichier en sortie
self.enregistrerSortie = enregistrerSortie
# Sélection du codec en sortie (par l'utilisateur)
self.codec_sortie = codec_sortie
# Sélection de la largeur (vidéo) en sortie (par l'utilisateur)
self.reso_largeur_sortie = reso_largeur_sortie
# Sélection de la hauteur (vidéo) en sortie (par l'utilisateur)
self.reso_hauteur_sortie = reso_hauteur_sortie
# Sélection du nbr d'img/sec en sortie (par l'utilisateur)
self.nbreImgSec_sortie = nbreImgSec_sortie
# Sélection de la qualité (de la vidéo) en sortie (par l'utilisateur)
self.qualite_sortie = qualite_sortie
# Widget qui appelle le traitement
self.parent = parent
### Ajouté le 13/08/2010 ###################################################
self.spec_sortie_DNxHD = spec_sortie_DNxHD
self.son_sortie_DNxHD = son_sortie_DNxHD
############################################################################
#self.fichiers = [os.path.basename(parc) for parc in self.cheminVideoEntre]
# Appel de la fonction appliquer
self.appliquer()
self.fichiers_traites = []
def appliquer(self):
self.labelAttente=QLabel()
self.labelAttente.setText(_(u"<p><b>Traitement des fichiers AVCHD par FFmpeg.</b></p><p>Traitement en cours, attendez la fin du calcul s'il vous plaît (soyez patient !)</p>"))
self.bout_annuler = QPushButton(_(u"Annuler"))
self.progress = QProgressBar()
self.progress.setMaximum(100)
self.progress.setValue(0)
vbox = QVBoxLayout()
vbox.addWidget(self.labelAttente)
hbox = QHBoxLayout()
hbox.addWidget(self.progress)
hbox.addWidget(self.bout_annuler)
vbox.addLayout(hbox)
self.setLayout(vbox)
self.connect(self.bout_annuler, SIGNAL('clicked()'), SLOT('close()'))
#self.th = FfmpegAvchd(self.cheminVideoEntre, self.enregistrerSortie, self.codec_sortie, self.reso_largeur_sortie, self.reso_hauteur_sortie, self.nbreImgSec_sortie, self.qualite_sortie, self.cheminFFmpeg)
### Rectification (le 13/08/2010) de self.spec_sortie_DNxHD et self.son_sortie_DNxHD #######
self.th = FfmpegAvchd(self.cheminVideoEntre, self.enregistrerSortie, self.codec_sortie, self.reso_largeur_sortie, self.reso_hauteur_sortie, self.nbreImgSec_sortie, self.qualite_sortie, self.spec_sortie_DNxHD, self.son_sortie_DNxHD, self.cheminFFmpeg)
# Connections pour l'appel et l'application du pourcentage dans la barre
# ... essai de récup du fichier chargé ... pour eventuellement pouvoir
# afficher le fichiers en cours dans la barre (au dessus de la barre
# elle même --> mais pas réussi à importer fichier_1 pour pouvoir
# l'afficher à la place de self.fichiers dans self.progress
self.th.connect(self.th, SIGNAL("increment(int)"), self.affichPourcent)
self.th.connect(self.th, SIGNAL("travail_avec_fichier"), self.fichierDeTravail)
self.th.connect(self.th, SIGNAL("fin process"), self.end)
self.progress.connect(self.progress, SIGNAL("canceled()"), self.th, SLOT("cancel()"))
self.progress.show()
self.th.start()
def end(self) :
debug(u"Conversion AVCHD terminé")
self.parent.actionsFin(self.fichiers_traites)
# On ajoute un parametre à la méthode
def affichPourcent(self, pourcent):
self.progress.setValue(pourcent)
QApplication.processEvents()
# Quand la progression arrive à 100%, la fenêtre
# contenant la QProgressBar se ferme
if pourcent == 100: self.close()
# De même, on ajoute un parametre à la méthode
def fichierDeTravail(self, fichier_1, out):
self.fichiers_traites.append(out)
debug(u'Fichier chargé: %s' % fichier_1)
class Entity(QWidget):
def __init__(self, base_image, size, hp=100, pos=(0, 0), parent=None):
super().__init__(parent)
self._base_label = QLabel(self)
self._base_image = base_image
self._size = size
self._decor_label = None
self._decor_pixmap = None
self._hp_max = hp
self.__pixmap = None
""":type: PyQt4.QtGui.QPixmap"""
self.__cord_x = pos[0]
self.__cord_y = pos[1]
self.__angle = 0
self.__hp_bar = QProgressBar(self)
self.__hp_bar.setMaximum(self._hp_max)
self.__hp_bar.setValue(self._hp_max)
self.__hp_bar.setTextVisible(False)
self.__hp_bar.setMaximumSize(size[0], 5)
self.setAlignment(Qt.AlignCenter)
self.updatePixmap()
if _debugging:
self.setStyleSheet("border: 1px solid black")
@property
def health(self):
return self.__hp_bar.value()
@health.setter
def health(self, hp):
if hp > self._hp_max:
hp = self._hp_max
elif hp < 0:
hp = 0
self.__hp_bar.setValue(hp)
@property
def angle(self):
return self.__angle
@angle.setter
def angle(self, angle):
self.__angle = angle
self.updatePixmap()
@property
def cord_x(self):
return self.__cord_x
@cord_x.setter
def cord_x(self, cord):
self.__cord_x = cord
self.move(self.cord_x, self.cord_y)
@property
def cord_y(self):
return self.__cord_y
@cord_y.setter
def cord_y(self, cord):
self.__cord_y = cord
self.move(self.cord_x, self.cord_y)
def hide_hp_bar(self, bool=False):
if bool:
self.__hp_bar.hide()
else:
self.__hp_bar.show()
def add_decoration(self, path):
if path is None:
self._decor_label.deleteLater()
self._decor_label = None
else:
self._decor_label = QLabel(self)
self._decor_pixmap = QPixmap(path)
# self._decor_pixmap = self._decor_pixmap.scaled(self._size[0], self._size[1])
self._decor_pixmap = self._decor_pixmap.transformed(
QTransform().rotate(self.angle))
self._decor_label.setPixmap(self._decor_pixmap)
self._decor_label.setAlignment(Qt.AlignCenter)
self._decor_label.show()
def updatePixmap(self):
path = get_asset_path(self._base_image)
self.__pixmap = QPixmap(path)
self.__pixmap = self.__pixmap.scaled(self._size[0], self._size[1])
self.__pixmap = self.__pixmap.transformed(QTransform().rotate(
self.angle))
self._base_label.setPixmap(self.__pixmap)
self._base_label.show()
# self.setFixedSize(self.__pixmap.width(), self.__pixmap.height())
def setFixedSize(self, x, y):
super().setFixedSize(x, y)
self._base_label.setFixedSize(x, y)
def setAlignment(self, alignment):
self._base_label.setAlignment(alignment)
class GUI(QWidget):
def __init__(self, parent=None):
super(GUI, self).__init__(parent)
self.create_ui_components()
self.compose_ui()
# Initializing: window composition, it's contents and event handlers
self.init_composition()
self.init_contents()
self.init_actions()
self.on_start()
def create_ui_components(self):
"""
Create layouts and qt controls.
"""
self.layout = QGridLayout()
self.kanjiGroup = QGroupBox()
self.kanjiLayout = QGridLayout()
# Kanji ui group
self.day, self.week, self.month, self.year = \
QLabel(KANJI), QLabel(KANJI), QLabel(KANJI), QLabel(KANJI)
self.dayLabel, self.weekLabel, self.monthLabel, self.yearLabel = \
QLabel('<b>Day</b>'), QLabel('<b>Week</b>'), \
QLabel('<b>Month</b>'), QLabel('<b>Year</b>')
# Main layout
self.showAbout = QPushButton('A&bout')
# DB controls (top)
self.showDB, self.availableDB, self.changeDB = \
QPushButton('&Change DB (active:)'), QComboBox(), QPushButton('&Remap')
# General controls (bottom)
self.getAll, self.showStats, self.quitApp, self.authGen, self.methodCombo = \
QPushButton('&Get all'), QPushButton('&Stats'), QPushButton('&Quit'), \
QPushButton('&Auth'), QComboBox()
# Notifications
self.progressBar = QProgressBar()
self.statusMessage = QLabel()
# About
self.aboutBox = QMessageBox()
def compose_ui(self):
"""
Fill layouts and groups, initialize filters.
"""
self.kanjiLayout.addWidget(self.day, 0, 0)
self.kanjiLayout.addWidget(self.week, 0, 1)
self.kanjiLayout.addWidget(self.dayLabel, 1, 0)
self.kanjiLayout.addWidget(self.weekLabel, 1, 1)
self.kanjiLayout.addWidget(self.month, 2, 0)
self.kanjiLayout.addWidget(self.year, 2, 1)
self.kanjiLayout.addWidget(self.monthLabel, 3, 0)
self.kanjiLayout.addWidget(self.yearLabel, 3, 1)
self.kanjiGroup.setLayout(self.kanjiLayout)
self.layout.addWidget(self.showDB, 0, 0, 1, 2)
self.layout.addWidget(self.availableDB, 1, 0)
self.layout.addWidget(self.changeDB, 1, 1)
self.layout.addWidget(self.kanjiGroup, 2, 0, 1, 2)
self.layout.addWidget(self.getAll, 3, 0)
self.layout.addWidget(self.showStats, 3, 1)
self.layout.addWidget(self.methodCombo, 4, 0)
self.layout.addWidget(self.authGen, 4, 1)
#self.layout.addWidget(self.quitApp, 5, 0, 1, 2)
self.layout.addWidget(self.quitApp, 5, 0)
self.layout.addWidget(self.showAbout, 5, 1)
self.layout.addWidget(self.progressBar, 6, 0, 1, 2)
self.layout.addWidget(self.statusMessage, 7, 0, 1, 2)
self.setLayout(self.layout)
self.eFilter = LabelEventFilter()
def on_start(self):
"""
Additional procedures run on application start.
"""
# Let's initialize even some stuff!
self.al = None
self.auth_thread = None
self.init_backend()
choose_db(str(self.availableDB.currentText()))
self.showDB.setText("&Change DB (active: %s)" % self.availableDB.currentText())
self.stats = StatsUI(self.al, self)
def init_composition(self):
"""
Window composition and general params.
"""
self.setWindowTitle(NAME + ' ' + __version__)
desktop = QApplication.desktop()
self.setGeometry((desktop.width() - WIDTH)/2,
(desktop.height() - HEIGHT)/2, WIDTH, HEIGHT)
def init_contents(self):
"""
Setting up qt controls.
"""
self.changeDB.hide()
self.availableDB.hide()
self.availableDB.addItems(dbs.keys())
self.kanjiGroup.setAlignment(Qt.AlignCenter)
self.kanjiGroup.setStyleSheet("QGroupBox { border: 1px solid gray; border-radius: 3px; }")
self.day.setAlignment(Qt.AlignCenter)
self.week.setAlignment(Qt.AlignCenter)
self.month.setAlignment(Qt.AlignCenter)
self.year.setAlignment(Qt.AlignCenter)
self.dayLabel.setAlignment(Qt.AlignCenter)
self.weekLabel.setAlignment(Qt.AlignCenter)
self.monthLabel.setAlignment(Qt.AlignCenter)
self.yearLabel.setAlignment(Qt.AlignCenter)
self.day.setFont(QFont(PRETTY_FONT, KANJI_SIZE))
self.week.setFont(QFont(PRETTY_FONT, KANJI_SIZE))
self.month.setFont(QFont(PRETTY_FONT, KANJI_SIZE))
self.year.setFont(QFont(PRETTY_FONT, KANJI_SIZE))
self.methodCombo.addItems(RandomMess.algs.keys())
self.methodCombo.setCurrentIndex(1)
self.statusMessage.setAlignment(Qt.AlignCenter)
self.statusMessage.hide()
self.statusMessage.setMaximumHeight(MESSAGE_HEIGHT)
self.statusMessage.setStyleSheet(WARNING_STYLE)
self.progressBar.setMaximum(0)
self.progressBar.setMaximumHeight(PROGRESS_HEIGHT)
self.progressBar.hide()
QToolTip.setFont(QFont(PRETTY_FONT, TOOLTIP_FONT_SIZE))
self.getAll.setToolTip('Randomly select all 4 kanji')
self.methodCombo.setToolTip('Choose algorithm for randomness')
self.authGen.setToolTip('Authorize on remote RNG services')
self.showStats.setToolTip('Show/hide dialog with comprehensive statistics')
self.quitApp.setToolTip('Close application')
self.showDB.setToolTip('Show/hide available databases')
self.availableDB.setToolTip('Available kanji frequency charts db')
self.changeDB.setToolTip('Pick new kanji from currently selected db')
# About dialog
self.aboutBox.layout().itemAt(1).widget().setAlignment(Qt.AlignLeft)
self.aboutBox.setTextFormat(Qt.RichText)
self.aboutBox.setText('Version:\t<b>' + __version__ + '</b><br/>Python:\t<b>' + platform.python_version() + '</b>' +
'<br/>Platform:\t<b>' + platform.system() + ' ' + platform.release() + '</b>' +
'<br/>Author:\t<b>' + __author__ + '</b>' + app_about)
self.aboutBox.setWindowTitle('About ' + app_name)
self.aboutBox.setIconPixmap(QPixmap(paths['icon']))
def init_actions(self):
"""
Binding events/handlers.
"""
self.showDB.clicked.connect(self.show_available_db)
self.changeDB.clicked.connect(self.change_db)
self.quitApp.clicked.connect(self.close)
self.getAll.clicked.connect(self.get_all)
self.authGen.clicked.connect(self.auth_task)
self.showStats.clicked.connect(self.show_stats)
self.methodCombo.currentIndexChanged.connect(self.update_alg)
self.showAbout.clicked.connect(self.app_help)
# Mouse events for labels
self.day.setAttribute(Qt.WA_Hover, True)
self.week.setAttribute(Qt.WA_Hover, True)
self.month.setAttribute(Qt.WA_Hover, True)
self.year.setAttribute(Qt.WA_Hover, True)
self.day.installEventFilter(self.eFilter)
self.week.installEventFilter(self.eFilter)
self.month.installEventFilter(self.eFilter)
self.year.installEventFilter(self.eFilter)
##### actions #####
def show_stats(self):
if self.stats.isVisible():
self.stats.hide()
else:
self.stats.show()
def show_available_db(self):
if self.availableDB.isVisible():
self.availableDB.hide()
self.changeDB.hide()
else:
self.availableDB.show()
self.changeDB.show()
def change_db(self):
try:
choose_db(str(self.availableDB.currentText()))
self.availableDB.hide()
self.changeDB.hide()
self.show_message_then_hide("DB successfully remaped!", False)
self.showDB.setText("&Change DB (active: %s)" % self.availableDB.currentText())
self.stats.update_stat_info()
self.stats.refresh_plot()
except NoDbException as e:
self.show_message_then_hide(e.message)
def get_all(self):
self.random_kanji_task = RandomKanjiTask(self.al)
self.random_kanji_task.done.connect(self.update_kanji)
self.show_progress('Selecting kanji...')
self.random_kanji_task.start()
def update_kanji(self, results):
if results['success']:
kanji_set = results['kanji_set']
for_a_day = kanji_set.pop()
for_a_week = kanji_set.pop()
for_a_month = kanji_set.pop()
for_a_year = kanji_set.pop()
self.day.setText(for_a_day.character)
self.dayLabel.setText('<b>Day:</b> ' + str(for_a_day.frequency) + ' | '
+ str(for_a_day.dominance) + '%')
self.week.setText(for_a_week.character)
self.weekLabel.setText('<b>Week:</b> ' + str(for_a_week.frequency) + ' | '
+ str(for_a_week.dominance) + '%')
self.month.setText(for_a_month.character)
self.monthLabel.setText('<b>Month:</b> ' + str(for_a_month.frequency) + ' | '
+ str(for_a_month.dominance) + '%')
self.year.setText(for_a_year.character)
self.yearLabel.setText('<b>Year:</b> ' + str(for_a_year.frequency) + ' | '
+ str(for_a_year.dominance) + '%')
self.kanji_tooltip(self.day)
self.kanji_tooltip(self.week)
self.kanji_tooltip(self.month)
self.kanji_tooltip(self.year)
if self.stats.isVisible():
self.stats.update_stat_info()
self.stats.refresh_plot()
self.hide_message()
else:
self.show_message_then_hide(results['message'])
self.hide_progress()
def pretty_font(self):
pass
def update_alg(self):
self.al.set_active(str(self.methodCombo.currentText()))
def init_backend(self):
self.al = RandomMess()
self.update_alg()
def auth_task(self):
self.auth_thread = AuthorizationTask(self.al)
self.auth_thread.done.connect(self.auth_complete)
#self.auth_thread.run()
# IT DOESN't work on windows as it should!
self.auth_thread.start()
self.show_progress('Authorizing on RNG services...')
def auth_complete(self, success):
self.hide_message()
self.hide_progress()
if success:
self.show_message_then_hide("Successfully authenticated!", False)
else:
self.show_message_then_hide("Sorry, could not authenticate.")
def show_message_then_hide(self, message, error=True):
if error:
self.statusMessage.setStyleSheet(WARNING_STYLE)
else:
self.statusMessage.setStyleSheet(NOTE_STYLE)
self.statusMessage.setText(message)
self.statusMessage.show()
QTimer.singleShot(MESSAGE_TIMEOUT, self.hide_message)
def show_progress(self, message):
self.statusMessage.setStyleSheet(NOTE_STYLE)
self.statusMessage.setText(message)
self.statusMessage.show()
self.progressBar.show()
def hide_message(self):
self.statusMessage.setText('')
self.statusMessage.hide()
def hide_progress(self):
self.progressBar.hide()
def toggle_kanji_info(self, label, info):
label.setToolTip(info.info())
def kanji_tooltip(self, label):
found = JDIC.search(label.text())
if found:
label.setToolTip(found.info())
else:
label.setToolTip('No such kanji in kanjidic2!')
def kanji_info(self, kanji):
pass
def app_help(self):
self.aboutBox.show()
#### Utility events ####
def resizeEvent(self, QResizeEvent):
self.updateStatsPosition()
self.updateStatsSize()
def moveEvent(self, QMoveEvent):
self.updateStatsPosition()
self.updateStatsSize()
def updateStatsPosition(self):
self.stats.move(self.x() + self.width() + 20, self.y())
def updateStatsSize(self):
self.stats.resize(QSize(self.stats.width(), self.height()))
class frmReportes( QPrintPreviewDialog ):
"""
Este es un formulario generico que muestra los reportes web generados para las
"""
def __init__( self, web, printer , parent = None ):
"""
@param web: La dirección web a la que apunta el reporte
@param printer: El objeto QPrinter en el que se imprime, esto es usado por si se desea alguna configuración especifica del reporte
"""
super( frmReportes, self ).__init__( printer, parent )
base = Reports.url
if base == "":
raise UserWarning( u"No existe una configuración para el servidor de reportes" )
self.report = base + web + "&uname=" + user.LoggedUser.user + "&hash=" + user.LoggedUser.hash
self.webview = QWebView()
self.setWindowFlags( self.windowFlags() | Qt.WindowMaximizeButtonHint )
self.txtSearch = QLineEdit()
self.loaded = False
self.webview.load( QUrl( self.report ) )
self.progressbar = QProgressBar( self )
self.paintRequested[QPrinter].connect( self.reprint )
self.webview.loadFinished[bool].connect( self.on_webview_loadFinished )
self.webview.loadProgress[int].connect( self.on_webview_loadProgress )
def reprint( self, printer ):
self.webview.print_( printer )
def on_webview_loadProgress( self, progress ):
self.progressbar.setValue( progress )
def showEvent( self, _event ):
if not self.loaded:
self.progressbar.show()
def on_webview_loadFinished( self, status ):
if self.progressbar.isVisible():
self.progressbar.hide()
if not status:
QMessageBox.critical( self, qApp.organizationName(), "El reporte no se pudo cargar" )
logging.error( "No se pudo cargar el reporte: %s" % self.report )
self.accept()
self.loaded = True
w = self.findChild( QPrintPreviewWidget )
w.updatePreview()
class MainWindow(KXmlGuiWindow):
"Class which displays the main Danbooru Client window."
def __init__(self, *args):
"Initialize a new main window."
super(MainWindow, self).__init__(*args)
self.cache = KPixmapCache("danbooru")
self.preferences = preferences.Preferences()
self.api = None
self.__ratings = None
self.__step = 0
self.url_list = self.preferences.boards_list
self.max_retrieve = self.preferences.thumbnail_no
self.statusbar = self.statusBar()
self.progress = QProgressBar()
self.thumbnailarea = None
self.tag_dock = None
self.pool_dock = None
self.first_fetch_widget = None
self.progress.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
# FIXME: Hackish, but how to make it small otherwise?
self.progress.setMinimumSize(100, 1)
self.statusbar.addPermanentWidget(self.progress)
self.progress.hide()
self.setup_welcome_widget()
self.setup_actions()
def reload_config(self):
"""Reload configuration after a change"""
urls = self.preferences.boards_list
if self.first_fetch_widget is not None:
self.first_fetch_widget.setup_urls(urls)
if self.thumbnailarea is not None:
max_thumbnail = self.preferences.thumbnail_no
max_rating = self.preferences.max_allowed_rating
self.thumbnailarea.fetchwidget.limit = max_thumbnail
self.thumbnailarea.fetchwidget.rating = max_rating
self.thumbnailarea.fetchwidget.update_values()
self.thumbnailarea.connectwidget.setup_urls(urls)
self.url_list = self.preferences.boards_list
self.max_retrieve = self.preferences.thumbnail_no
def setup_welcome_widget(self):
"""Load the welcome widget at startup."""
widget = QWidget()
layout = QVBoxLayout()
welcome = QLabel(parent=self)
pix = QPixmap(KStandardDirs.locate("appdata", "logo.png"))
welcome.setPixmap(pix)
welcome.setAlignment(Qt.AlignCenter)
self.first_fetch_widget = connectwidget.ConnectWidget(
self.preferences.boards_list, self)
self.statusbar.addPermanentWidget(self.first_fetch_widget, 300)
self.first_fetch_widget.connectionEstablished.connect(
self.handle_connection)
self.first_fetch_widget.rejected.connect(self.first_fetch_widget.hide)
self.first_fetch_widget.hide()
self.first_fetch_widget.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Fixed)
layout.addWidget(self.first_fetch_widget)
layout.addWidget(welcome)
widget.setLayout(layout)
self.setCentralWidget(widget)
def setup_tooltips(self):
"""Set tooltips for the actions."""
self.connect_action.setToolTip(i18n("Connect to a Danbooru board"))
self.fetch_action.setToolTip(
i18n("Fetch thumbnails from a Danbooru board"))
self.batch_download_action.setToolTip(i18n("Batch download images"))
def create_actions(self):
"""Create actions for the main window."""
self.connect_action = KAction(KIcon("document-open-remote"),
i18n("Connect"), self)
self.fetch_action = KAction(KIcon("download"), i18n("Download"), self)
self.clean_action = KAction(KIcon("trash-empty"),
i18n("Clear thumbnail cache"), self)
self.batch_download_action = KAction(KIcon("download"),
i18n("Batch download"), self)
self.pool_toggle_action = KToggleAction(KIcon("image-x-generic"),
i18n("Pools"), self)
self.tag_display_action = KDualAction(i18n("Show tags"),
i18n("Hide tags"), self)
self.tag_display_action.setIconForStates(KIcon("image-x-generic"))
self.tag_display_action.setEnabled(False)
# Shortcuts
connect_default = KAction.ShortcutTypes(KAction.DefaultShortcut)
connect_active = KAction.ShortcutTypes(KAction.ActiveShortcut)
self.connect_action.setShortcut(KStandardShortcut.open())
self.fetch_action.setShortcut(KStandardShortcut.find())
self.fetch_action.setEnabled(False)
self.batch_download_action.setEnabled(False)
self.pool_toggle_action.setEnabled(False)
def setup_action_collection(self):
"""Set up the action collection by adding the actions."""
action_collection = self.actionCollection()
# Addition to the action collection
action_collection.addAction("connect", self.connect_action)
action_collection.addAction("fetch", self.fetch_action)
action_collection.addAction("clean", self.clean_action)
action_collection.addAction("batchDownload",
self.batch_download_action)
action_collection.addAction("poolDownload", self.pool_toggle_action)
action_collection.addAction("tagDisplay", self.tag_display_action)
KStandardAction.quit(self.close, action_collection)
KStandardAction.preferences(self.show_preferences, action_collection)
action_collection.removeAction(
action_collection.action("help_contents"))
action_collection.actionHovered.connect(self.setup_action_tooltip)
def setup_actions(self):
"""Set up the relevant actions, tooltips, and load the RC file."""
self.create_actions()
self.setup_tooltips()
self.setup_action_collection()
# Connect signals
self.connect_action.triggered.connect(self.connect)
self.fetch_action.triggered.connect(self.get_posts)
self.clean_action.triggered.connect(self.clean_cache)
self.batch_download_action.triggered.connect(self.batch_download)
self.pool_toggle_action.toggled.connect(self.pool_toggle)
self.tag_display_action.activeChanged.connect(self.tag_display)
window_options = self.StandardWindowOption(self.ToolBar | self.Keys
| self.Create | self.Save
| self.StatusBar)
setupGUI_args = [
QSize(500, 400),
self.StandardWindowOption(window_options)
]
#Check first in standard locations for danbooruui.rc
rc_file = KStandardDirs.locate("appdata", "danbooruui.rc")
if rc_file.isEmpty():
setupGUI_args.append(os.path.join(sys.path[0], "danbooruui.rc"))
else:
setupGUI_args.append(rc_file)
self.setupGUI(*setupGUI_args)
def setup_action_tooltip(self, action):
"Show statusbar help when actions are hovered."
if action.isEnabled():
self.statusBar().showMessage(action.toolTip(), 2000)
def setup_connections(self):
"""Set up connections for post and tag retrieval."""
if self.api is None:
return
self.api.postRetrieved.connect(self.update_progress)
self.api.postDownloadFinished.connect(self.download_finished)
self.api.tagRetrieved.connect(self.tag_dock.widget().add_tags)
self.tag_dock.widget().itemDoubleClicked.connect(
self.fetch_tagged_items)
def show_preferences(self):
"Show the preferences dialog."
if KConfigDialog.showDialog("Preferences dialog"):
return
else:
dialog = preferences.PreferencesDialog(self, "Preferences dialog",
self.preferences)
dialog.show()
dialog.settingsChanged.connect(self.reload_config)
def connect(self, ok):
"Connect to a Danbooru board."
if self.thumbnailarea is None:
self.first_fetch_widget.show()
else:
self.thumbnailarea.connectwidget.show()
def restore(self):
self.statusbar.removeWidget(self.connect_widget)
def handle_connection(self, connection):
self.api = None
self.api = connection
self.api.cache = self.cache
if self.pool_dock is not None:
self.pool_dock.hide()
self.pool_dock.widget().clear()
self.pool_toggle_action.setChecked(False)
if self.thumbnailarea is not None:
#TODO: Investigate usability
self.clear(clear_pool=True)
self.thumbnailarea.clear()
self.thumbnailarea.api_data = self.api
self.setup_connections()
else:
self.first_fetch_widget.connectionEstablished.disconnect()
self.first_fetch_widget.rejected.disconnect()
self.statusbar.removeWidget(self.first_fetch_widget)
self.setup_area()
self.api.cache = self.cache
self.statusBar().showMessage(i18n("Connected to %s" % self.api.url),
3000)
self.fetch_action.setEnabled(True)
# Set up pool widget
pool_widget = poolwidget.DanbooruPoolWidget(self.api)
self.pool_dock = QDockWidget("Pools", self)
self.pool_dock.setObjectName("PoolDock")
self.pool_dock.setAllowedAreas(Qt.BottomDockWidgetArea)
self.pool_dock.setWidget(pool_widget)
#self.pool_dock.setFeatures(QDockWidget.NoDockWidgetFeatures)
self.addDockWidget(Qt.BottomDockWidgetArea, self.pool_dock)
self.pool_dock.widget().poolDownloadRequested.connect(
self.pool_prepare)
self.pool_dock.hide()
self.pool_toggle_action.setEnabled(True)
self.clear() # Needed to show properly the stuff after connecting
self.api.get_post_list(tags="",
limit=self.thumbnailarea.post_limit,
rating=self.preferences.max_allowed_rating,
blacklist=list(self.preferences.tag_blacklist))
self.api.get_tag_list(name="",
blacklist=list(self.preferences.tag_blacklist),
limit=20)
def get_posts(self, ok):
"Get posts from the connected Danbooru board."
if not self.api:
return
self.thumbnailarea.fetchwidget.show()
def handle_fetching(self, tags, max_rating, limit):
"""Slot connected to the dataSent signal of the fetch widget.
The widgets are set up if they don't exist, and the API is queried
to do the actual downloading of tags and
"""
self.clear()
self.thumbnailarea.fetchwidget.hide()
if self.tag_dock is not None:
self.tag_dock.widget().clear()
self.thumbnailarea.post_limit = limit
blacklist = list(self.preferences.tag_blacklist)
self.api.get_post_list(tags=tags,
limit=limit,
rating=max_rating,
blacklist=blacklist)
tags = [item for item in tags if item]
if not tags:
# No related tags, fetch the most recent 20
tags = ""
self.api.get_tag_list(name=tags, blacklist=blacklist, limit=20)
else:
self.api.get_related_tags(tags=tags, blacklist=blacklist)
def fetch_tagged_items(self, item):
"""Fetch items found in the tag list widget."""
tag_name = unicode(item.text())
self.clear()
blacklist = self.preferences.tag_blacklist
limit = self.preferences.thumbnail_no
rating = self.preferences.max_allowed_rating
self.api.get_post_list(page=1,
tags=[tag_name],
blacklist=blacklist,
limit=limit,
rating=rating)
self.api.get_related_tags(tags=[tag_name], blacklist=blacklist)
def pool_toggle(self, checked):
"Toggle the presence/absence of the pool dock."
if not self.api:
return
if not checked:
self.pool_dock.hide()
else:
self.pool_dock.show()
def pool_prepare(self, pool_id):
"""Prepare the central area for pool image loading."""
if self.thumbnailarea is None:
self.setup_area()
else:
self.clear(clear_pool=False)
self.api.get_pool(pool_id,
blacklist=self.preferences.tag_blacklist,
rating=self.preferences.max_allowed_rating)
def batch_download(self, ok):
"Download images in batch."
selected_items = self.thumbnailarea.selected_images()
if not selected_items:
return
start_url = KUrl("kfiledialog:///danbooru")
caption = i18n("Select a directory to save the images to")
directory = KFileDialog.getExistingDirectoryUrl(
start_url, self, caption)
if directory.isEmpty():
return
for item in selected_items:
file_url = item.url_label.url()
tags = item.data.tags
# Make a local copy to append paths as addPath works in-place
destination = KUrl(directory)
file_name = KUrl(file_url).fileName()
destination.addPath(file_name)
job = KIO.file_copy(KUrl(file_url), destination, -1)
job.setProperty("tags", QVariant(tags))
job.result.connect(self.batch_download_slot)
def setup_area(self):
"Set up the central widget to display thumbnails."
self.thumbnailarea = thumbnailarea.DanbooruTabWidget(
self.api, self.preferences, self.preferences.thumbnail_no, self)
self.setCentralWidget(self.thumbnailarea)
self.thumbnailarea.connectwidget.connectionEstablished.connect(
self.handle_connection, type=Qt.UniqueConnection)
self.thumbnailarea.connectwidget.rejected.connect(
self.thumbnailarea.connectwidget.hide, type=Qt.UniqueConnection)
self.thumbnailarea.fetchwidget.dataSent.connect(
self.handle_fetching, type=Qt.UniqueConnection)
self.thumbnailarea.fetchwidget.rejected.connect(
self.thumbnailarea.fetchwidget.hide, type=Qt.UniqueConnection)
# Set up tag widget
blacklist = self.preferences.tag_blacklist
tag_widget = tagwidget.DanbooruTagWidget(blacklist, self)
self.tag_display_action.setActive(True)
self.tag_display_action.setEnabled(True)
self.tag_dock = QDockWidget("Similar tags", self)
self.tag_dock.setObjectName("TagDock")
self.tag_dock.setAllowedAreas(Qt.RightDockWidgetArea)
self.tag_dock.setWidget(tag_widget)
#self.tag_dock.setFeatures(QDockWidget.NoDockWidgetFeatures)
self.addDockWidget(Qt.RightDockWidgetArea, self.tag_dock)
self.tag_dock.hide()
# Container signal-slot connections
self.setup_connections()
def download_finished(self):
"""Slot called when all the data has been completed. Clears the progress
bar and resets it to 0."""
if not self.batch_download_action.isEnabled():
self.batch_download_action.setEnabled(True)
self.__step = 0
self.progress.hide()
def update_progress(self):
"Update the progress bar."
if not self.progress.isVisible():
self.progress.show()
self.__step += 1
self.progress.setValue(self.__step)
def clear(self, clear_pool=True):
"Clear the central widget."
if self.thumbnailarea is None:
return
self.thumbnailarea.clear()
self.tag_dock.widget().clear()
if clear_pool:
self.pool_dock.widget().clear()
self.batch_download_action.setEnabled(False)
def clean_cache(self):
"Purge the thumbnail cache."
self.cache.discard()
self.statusBar().showMessage(i18n("Thumbnail cache cleared."))
def batch_download_slot(self, job):
"""Slot called when doing batch download, for each file retrieved.
If Nepomuk tagging is enabled, each file is tagged using the item's
respective tags.
"""
if job.error():
job.ui().showErrorMessage()
else:
if self.preferences.nepomuk_enabled:
tags = job.property("tags").toPyObject()
#danbooru2nepomuk.tag_danbooru_item(job.destUrl().path(),
# tags)
def tag_display(self, state):
"""Display or hide the tag dock."""
if self.tag_dock is None:
self.tag_display_action.setActive(False)
return
if state:
self.tag_dock.show()
else:
self.tag_dock.hide()
class MainWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.setCentralWidget(self.ui.mangaTableView)
self.newMangaDialog = NewMangaDialog()
self.mangaDownloadDialog = MangaDownloadDialog()
self.mangaTableModel = QStandardItemModel(0, 3, self)
self.mangaTableModel.setHorizontalHeaderItem(0, QStandardItem(QString("Manga")))
self.mangaTableModel.setHorizontalHeaderItem(1, QStandardItem(QString("Latest Chapter")))
self.mangaTableModel.setHorizontalHeaderItem(2, QStandardItem(QString("Status")))
self.ui.mangaTableView.setModel(self.mangaTableModel)
newMangaAction = QAction(QIcon("./icon/add.ico"),'New Manga', self)
newMangaAction.setShortcut('Ctrl+N')
newMangaAction.triggered.connect(self.newMangaDialog.show)
removeMangaAction = QAction(QIcon("./icon/delete.ico"),'Remove Manga', self)
removeMangaAction.setShortcut('Delete')
preferencesAction = QAction(QIcon("./icon/preferences.ico"),'Preferences', self)
aboutAction = QAction(QIcon("./icon/about.ico"),'About', self)
self.ui.toolBar.addAction(newMangaAction)
self.ui.toolBar.addAction(removeMangaAction)
self.ui.toolBar.addSeparator()
self.ui.toolBar.addAction(preferencesAction)
self.ui.toolBar.addSeparator()
self.ui.toolBar.addAction(aboutAction)
self.progressBar = QProgressBar(self.ui.statusbar)
self.ui.statusbar.addPermanentWidget(self.progressBar)
self.progressBar.hide()
def closeEvent(self, QCloseEvent):
mangaList = []
for i in range(self.mangaTableModel.rowCount()):
mangaList.append({
"name" : str(self.mangaTableModel.item(i, 0).text()),
"latestChapter" : str(self.mangaTableModel.item(i, 1).text()),
"status" : "Updated",
"link" : "/trial.html"
})
self.emit(SIGNAL("applicationClosed"),mangaList)
def initializeProgressBar(self, size):
self.progressBar.setRange(0, size)
self.progressBar.setValue(0)
self.progressBar.show()
def updateProgressBar(self, value):
self.progressBar.setValue(value)
def updateStatusBar(self, msg):
self.ui.statusbar.showMessage(msg)
def updateMangaTable(self, chapter):
isFound = False
for i in range(self.mangaTableModel.rowCount()):
mangaItem = self.mangaTableModel.item(i)
if mangaItem.text() == chapter["name"]:
self.mangaTableModel.item(i, 1).setText(chapter["latestChapter"])
self.mangaTableModel.item(i, 2).setText(chapter["status"])
isFound = True
break
if not isFound:
self.addRowToMangaTable(chapter)
def addMangaListToMangaTable(self, mangaList):
for i in range(len(mangaList)):
self.addRowToMangaTable(mangaList[i])
def addRowToMangaTable(self, manga):
i = self.mangaTableModel.rowCount()
mangaItem = QStandardItem(QString(manga["name"]))
latestChapterItem = QStandardItem(QString(manga["latestChapter"]))
statusItem = QStandardItem(QString(manga["status"]))
brush = QBrush(QColor(255, 255, 255)) if i%2==0 else QBrush(QColor(200, 200, 200))
mangaItem.setBackground(brush)
latestChapterItem.setBackground(brush)
statusItem.setBackground(brush)
self.mangaTableModel.setItem(i, 0, mangaItem)
self.mangaTableModel.setItem(i, 1, latestChapterItem)
self.mangaTableModel.setItem(i, 2, statusItem)
class InputForm(QWidget):
__instance = None
@staticmethod
def instance():
return InputForm.__instance
def __init__(self):
if not InputForm.__instance:
InputForm.__instance = self
super(InputForm, self).__init__()
Global.event.task_started.connect(self._on_task_started)
Global.event.task_completed.connect(self._on_task_completed)
Global.event.task_progressed.connect(self._on_task_progressed)
Global.event.task_range_progressed.connect(self._on_task_range_progressed)
Global.event.interface_load_task_params.connect(self._on_interface_load_task_params)
self.vl = QVBoxLayout()
self.vl.setContentsMargins(0,0,0,0)
self.setLayout(self.vl)
self.setFixedWidth(290)
self.tab = QTabWidget()
self.vl.addWidget(self.tab)
self.input_parameters = InputParameters()
self.input_parameters.ranges_state_changed.connect(self._on_ranges_state_changed)
self.tab.addTab(self.input_parameters, 'Parameters')
self.import_parameters = ImportParameters()
self.tab.addTab(self.import_parameters, 'Observation')
control_buttons = QWidget()
control_buttons.setLayout(QVBoxLayout())
control_buttons.layout().setContentsMargins(0, 0, 0, 0)
control_buttons.layout().setAlignment(Qt.AlignBottom)
self._progress = QProgressBar()
self._progress.setValue(0)
self._progress.setTextVisible(True)
self._progress.setAlignment(Qt.AlignCenter)
self._progress.hide()
control_buttons.layout().addWidget(self._progress)
self._range_progress = QProgressBar()
self._range_progress.setValue(0)
self._range_progress.setTextVisible(True)
self._range_progress.setAlignment(Qt.AlignCenter)
self._range_progress.hide()
control_buttons.layout().addWidget(self._range_progress)
self._calculate = QPushButton('Calculate')
self._calculate.clicked.connect(self._on_calculate)
control_buttons.layout().addWidget(self._calculate)
self._cancel = QPushButton('Cancel')
self._cancel.hide()
self._cancel.clicked.connect(self._on_cancel)
control_buttons.layout().addWidget(self._cancel)
self.vl.addWidget(control_buttons)
if exists("./config/last-session.ini") :
self.load_params("./config/last-session.ini")
def _on_ranges_state_changed(self, parameters):
Global.task_range().reset()
if len(parameters):
keys = parameters.keys()
for key in parameters:
Global.task_range().set_range(key, copy(parameters[key].range.values))
self._calculate.setText('Calculate ' + str(Global.task_range()._total_count) + ' variations')
else:
self._calculate.setText('Calculate')
def _on_calculate(self):
self.import_parameters.import_observation()
combination = Global.task_range().get_next_combination()
Global.task().input.semi_major_axis = self.input_parameters.semi_major_axis.getValue()
Global.task().input.star_radius = self.input_parameters.star_radius.getValue()
Global.task().input.planet_radius = self.input_parameters.planet_radius.getValue()
Global.task().input.star_temperature = self.input_parameters.star_temperature.getValue()
Global.task().input.planet_temperature = self.input_parameters.planet_temperature.getValue()
Global.task().input.darkening_law = self.input_parameters.darkening_law.value.itemData(self.input_parameters.darkening_law.value.currentIndex()).toString()
Global.task().input.darkening_1 = self.input_parameters.darkening_coefficient_1.getValue()
Global.task().input.darkening_2 = self.input_parameters.darkening_coefficient_2.getValue()
Global.task().input.inclination = self.input_parameters.inclination.getValue()
Global.task().input.phase_start = 0
Global.task().input.phase_end = self.input_parameters.phase_end.getValue()
Global.task().input.phase_step = self.input_parameters.phase_step.getValue()
Global.task().input.precision = 10**self.input_parameters.integration_precision.getValue()
if combination:
for param in combination:
setattr(Global.task().input, param[0], param[1])
Global.task().start()
def _on_task_range_progressed(self, progress):
self._range_progress.setFormat( str(Global.task_range().completed_count()) + ' of ' + str(Global.task_range().total_count()))
self._range_progress.setValue(math.ceil(((float(Global.task_range().completed_count()))/Global.task_range().total_count())*100))
self._on_calculate()
def _on_task_started(self, task):
self._calculate.hide()
self._progress.show()
self._progress.setValue(0)
self._cancel.show()
self.tab.setDisabled(True)
if Global.task_range().total_count():
self._range_progress.show()
if Global.task_range().completed_count() == 0:
self._range_progress.setFormat('0 of ' + str(Global.task_range().total_count()))
self._range_progress.setValue(0)
def _on_task_progressed(self, task, progress):
self._progress.setValue(progress)
def _on_task_completed(self, task):
if Global.task_range().total_count() and Global.task_range().completed_count():
return
self._calculate.show()
self._progress.hide()
self._progress.setValue(0)
self._cancel.hide()
self.tab.setDisabled(False)
self._range_progress.hide()
self._range_progress.setValue(0)
def _on_cancel(self):
Global.task().stop()
self._calculate.show()
self._progress.hide()
self._progress.setValue(0)
self._range_progress.hide()
self._range_progress.setValue(0)
self._cancel.hide()
self.tab.setDisabled(False)
def _on_interface_load_task_params(self, task):
self.input_parameters.semi_major_axis.value.setValue(task.input.semi_major_axis)
self.input_parameters.star_radius.value.setValue(task.input.star_radius)
self.input_parameters.planet_radius.value.setValue(task.input.planet_radius)
self.input_parameters.star_temperature.value.setValue(task.input.star_temperature)
self.input_parameters.planet_temperature.value.setValue(task.input.planet_temperature)
self.input_parameters.inclination.value.setValue(task.input.inclination)
darkening_law_index = 0
for item in DarkeningLaw.items:
if item[1] == task.input.darkening_law:
break
darkening_law_index += 1
self.input_parameters.darkening_law.value.setCurrentIndex(darkening_law_index)
self.input_parameters.darkening_coefficient_1.value.setValue(task.input.darkening_1)
self.input_parameters.darkening_coefficient_2.value.setValue(task.input.darkening_2)
self.input_parameters.phase_end.value.setValue(task.input.phase_end)
self.input_parameters.phase_step.value.setValue(task.input.phase_step)
self.input_parameters.integration_precision.value.setValue(log10(task.input.precision))
for parameter_name in copy(self.input_parameters.range_parameters):
parameter = getattr(self.input_parameters, parameter_name)
if parameter.range:
parameter.range.set_active(False)
self.repaint()
def load_params(self, filename):
config = ConfigParser()
config.read(filename)
self._normalize_config(config)
# Input Parameters
self._load_config_param(config, 'input', 'semi_major_axis')
self._load_config_param(config, 'input', 'star_radius')
self._load_config_param(config, 'input', 'planet_radius')
self._load_config_param(config, 'input', 'star_temperature')
self._load_config_param(config, 'input', 'planet_temperature')
self._load_config_param(config, 'input', 'inclination')
self._load_config_param(config, 'input', 'darkening_law')
self._load_config_param(config, 'input', 'darkening_coefficient_1')
self._load_config_param(config, 'input', 'darkening_coefficient_2')
self._load_config_param(config, 'input', 'phase_end')
self._load_config_param(config, 'input', 'phase_step')
self._load_config_param(config, 'input', 'integration_precision')
# Import Parameters
if config.has_option('import', 'filename') and config.get('import', 'filename'):
if '/data/' in config.get('import', 'filename') and config.get('import', 'filename').index('/data/') == 0:
self.import_parameters.filename = os.getcwd().replace('\\', '/') + config.get('import', 'filename')
else:
self.import_parameters.filename = config.get('import', 'filename')
self.import_parameters.update_file_label()
if config.has_option('import', 'jd2phase') and config.getboolean('import', 'jd2phase') == True :
self.import_parameters.hjd_to_phases.setCheckState(Qt.Checked)
if config.has_option('import', 'jd2phase_tzero') :
self.import_parameters.time_zero.setValue(config.getfloat('import', 'jd2phase_tzero'))
if config.has_option('import', 'jd2phase_period') :
self.import_parameters.period.setValue(config.getfloat('import', 'jd2phase_period'))
if config.has_option('import', 'mag2flux') and config.getboolean('import', 'mag2flux') == True :
self.import_parameters.magnitude_to_flux.setCheckState(Qt.Checked)
if config.has_option('import', 'mag2flux_mag') :
self.import_parameters.magnitude_max.setValue(config.getfloat('import', 'mag2flux_mag'))
# Fixes painting bug with range buttons when loading new file
# the active ranges stayed active even if they are inactive
self.repaint()
def _normalize_config(self, config):
if config.has_option('input', 'darkening_1'):
config.set('input', 'darkening_coefficient_1', config.get('input', 'darkening_1'))
config.remove_option('input', 'darkening_1')
if config.has_option('input', 'darkening_2'):
config.set('input', 'darkening_coefficient_2', config.get('input', 'darkening_2'))
config.remove_option('input', 'darkening_2')
if config.has_option('input', 'precision'):
config.set('input', 'integration_precision', config.get('input', 'precision'))
config.remove_option('input', 'precision')
def _load_config_param(self, config, section, name):
param = getattr(self.input_parameters, name)
if config.has_option(section, name):
if type(param.value) is QComboBox:
param.value.setCurrentIndex(config.getint(section, name))
else:
param.value.setValue(literal_eval(config.get(section, name)))
if param.range:
_from = _to = _step = _values = None
_active = False
if config.has_option(section, name + '_range_from'):
_from = literal_eval(config.get(section, name + '_range_from'))
if config.has_option(section, name + '_range_to'):
_to = literal_eval(config.get(section, name + '_range_to'))
if config.has_option(section, name + '_range_step'):
_step = literal_eval(config.get(section, name + '_range_step'))
if config.has_option(section, name + '_range_values'):
_values = literal_eval(config.get(section, name + '_range_values'))
if config.has_option(section, name + '_range_active'):
_active = config.getboolean(section, name + '_range_active')
if _values:
param.range.set_range(_values)
elif _from and _to and _step:
param.range.set_range(_from, _to, _step)
param.range.set_active(_active)
def _save_config_param(self, config, section, name):
param = getattr(self.input_parameters, name)
if type(param.value) is QComboBox:
config.set(section, name, param.value.currentIndex())
else:
config.set(section, name, param.getValue())
if param.range:
if param.range.range_from and param.range.range_to and param.range.range_step:
config.set(section, name + '_range_from', param.range.range_from)
config.set(section, name + '_range_to', param.range.range_to)
config.set(section, name + '_range_step', param.range.range_step)
elif param.range.values:
config.set(section, name + '_range_values', param.range.values)
if param.range.is_active():
config.set(section, name + '_range_active', param.range.is_active())
def save_params(self, filename):
config = ConfigParser()
config.add_section('input')
# Input Parameters
self._save_config_param(config, 'input', 'semi_major_axis')
self._save_config_param(config, 'input', 'star_radius')
self._save_config_param(config, 'input', 'planet_radius')
self._save_config_param(config, 'input', 'star_temperature')
self._save_config_param(config, 'input', 'planet_temperature')
self._save_config_param(config, 'input', 'inclination')
self._save_config_param(config, 'input', 'darkening_law')
self._save_config_param(config, 'input', 'darkening_coefficient_1')
self._save_config_param(config, 'input', 'darkening_coefficient_2')
self._save_config_param(config, 'input', 'phase_end')
self._save_config_param(config, 'input', 'phase_step')
self._save_config_param(config, 'input', 'integration_precision')
config.add_section('import')
if os.getcwd().replace('\\', '/') in str(self.import_parameters.filename) and str(self.import_parameters.filename).index(os.getcwd().replace('\\', '/')) == 0 :
save_file_path = str(self.import_parameters.filename).replace(os.getcwd().replace('\\', '/'), '')
else:
save_file_path = str(self.import_parameters.filename)
config.set('import', 'filename', save_file_path)
config.set('import', 'jd2phase', self.import_parameters.hjd_to_phases.checkState() == Qt.Checked)
config.set('import', 'jd2phase_tzero', self.import_parameters.time_zero.value())
config.set('import', 'jd2phase_period', self.import_parameters.period.value())
config.set('import', 'mag2flux', self.import_parameters.magnitude_to_flux.checkState() == Qt.Checked)
config.set('import', 'mag2flux_mag', self.import_parameters.magnitude_max.value())
with open(filename, 'wb') as configfile:
config.write(configfile)
pass
