def __init__(self, parent=None):
#super(MainWidget,self).__init__()
QWidget.__init__(self, parent) # burada bir hata var
self.setupUi(self)
self.parent = parent
self._selectedGroups = []
self._preexceptions = []
self._postexceptions = []
self.state = StateManager(self)
self.currentState = None
self.completer = None
self._updatesCheckedOnce = False
# Search Thread
self._searchThread = PThread(self, self.startSearch,
self.searchFinished)
self.statusUpdater = StatusUpdater()
self.basket = BasketDialog(self.state, self.parent)
self._postexceptions.append(lambda: self.basket.setActionEnabled(True))
self.searchButton.setIcon(KIcon(("edit-find", "find")))
self.initializeUpdateTypeList()
model = PackageModel(self)
proxy = PackageProxy(self)
proxy.setSourceModel(model)
self.packageList.setModel(proxy)
self.packageList.setItemDelegate(PackageDelegate(self, self.parent))
self.packageList.setColumnWidth(0, 32)
#burada hata alabilirim
self.packageList.model().dataChanged[QModelIndex, QModelIndex].connect(
self.statusChanged)
self.packageList.updateRequested.connect(self.initialize)
self.updateSettings()
self.setActionButton()
self.operation = OperationManager(self.state)
self.progressDialog = ProgressDialog(self.state, self.parent)
self._preexceptions.append(self.progressDialog._hide)
self.progressDialog.registerFunction(
FINISHED, lambda: self.parent.statusBar().setVisible(
not self.progressDialog.isVisible()))
self.progressDialog.registerFunction(
OUT, lambda: self.parent.statusBar().show())
self.summaryDialog = SummaryDialog()
self.connectOperationSignals()
self.pdsMessageBox = PMessageBox(self.content)
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.setupUi(self)
self.searchButton.setIcon(KIcon("edit-find"))
self.statusUpdater = StatusUpdater()
self.state = StateManager(self)
self.session = SessionManager()
self.basket = BasketDialog(self.state)
self.initialize()
self.setSelectAll()
self.actionButton.setIcon(self.state.getActionIcon())
self.operation = OperationManager(self.state)
self.progressDialog = ProgressDialog(self.state)
self.summaryDialog = SummaryDialog()
self.connectMainSignals()
self.connectOperationSignals()
def __init__(self, parent = None):
QWidget.__init__(self, parent)
self.setupUi(self)
self.parent = parent
self._selectedGroups = []
self._preexceptions = []
self._postexceptions = []
self.state = StateManager(self)
self.currentState = None
self.completer = None
self._updatesCheckedOnce = False
#set style
self._style = "/usr/share/kde4/apps/package-manager/data/style.qss"
self.setStyleSheet(file(self._style).read())
# Search Thread
self._searchThread = PThread(self, self.startSearch, self.searchFinished)
self.statusUpdater = StatusUpdater()
self.basket = BasketDialog(self.state, self.parent)
self._postexceptions.append(lambda: self.basket.setActionEnabled(True))
self.searchButton.setIcon(KIcon("edit-find"))
self.initializeUpdateTypeList()
self.morewidgets = MoreWidgets(self.state, self.parent)
self._postexceptions.append(lambda: self.morewidgets.setActionEnabled(True))
self.morewidgets._show()
self.webdialog = WebDialog(self.state, self.parent)
model = PackageModel(self)
proxy = PackageProxy(self)
proxy.setSourceModel(model)
self.packageList.setModel(proxy)
self.packageList.setItemDelegate(PackageDelegate(self, self.parent))
self.packageList.setColumnWidth(0, 32)
self.connect(self.packageList.model(), SIGNAL("dataChanged(QModelIndex,QModelIndex)"), self.statusChanged)
self.connect(self.packageList, SIGNAL("updateRequested()"), self.initialize)
self.connect(self.morewidgets.randomPackageList, SIGNAL("itemDoubleClicked(QListWidgetItem*)"), self.showWebdialog)
self.updateSettings()
self.setActionButton()
self.operation = OperationManager(self.state)
self.progressDialog = ProgressDialog(self.state, self.parent)
self._preexceptions.append(self.progressDialog._hide)
self.progressDialog.registerFunction(FINISHED, lambda: self.parent.statusBar().setVisible(not self.progressDialog.isVisible()))
self.progressDialog.registerFunction(OUT, lambda: self.parent.statusBar().show())
self.summaryDialog = SummaryDialog()
self.connectOperationSignals()
self.pdsMessageBox = PMessageBox(self.content)
def __init__(self, parent = None):
super(MainWidget, self).__init__(parent)
self.setupUi(self)
self.parent = parent
self._selectedGroups = []
self._preexceptions = []
self._postexceptions = []
self.state = StateManager(self)
self.currentState = None
self.completer = None
self._updatesCheckedOnce = False
# Search Thread
self._searchThread = PThread(self, self.startSearch, self.searchFinished)
self.statusUpdater = StatusUpdater()
self.basket = BasketDialog(self.state, self.parent)
self._postexceptions.append(lambda: self.basket.setActionEnabled(True))
self.searchButton.setIcon(KIcon(("edit-find", "find")))
self.initializeUpdateTypeList()
model = PackageModel(self)
proxy = PackageProxy(self)
proxy.setSourceModel(model)
self.packageList.setModel(proxy)
self.packageList.setItemDelegate(PackageDelegate(self, self.parent))
self.packageList.setColumnWidth(0, 32)
self.packageList.dataChanged[QModelIndex,QModelIndex].connect(self.statusChanged)
self.packageList.updateRequested.connect(self.initialize)
self.updateSettings()
self.setActionButton()
self.operation = OperationManager(self.state)
self.progressDialog = ProgressDialog(self.state, self.parent)
self._preexceptions.append(self.progressDialog._hide)
self.progressDialog.registerFunction(FINISHED, lambda: self.parent.statusBar().setVisible(not self.progressDialog.isVisible()))
self.progressDialog.registerFunction(OUT, lambda: self.parent.statusBar().show())
self.summaryDialog = SummaryDialog()
self.connectOperationSignals()
self.pdsMessageBox = PMessageBox(self.content)
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.setupUi(self)
self.searchButton.setIcon(KIcon("edit-find"))
self.statusUpdater = StatusUpdater()
self.state = StateManager(self)
self.basket = BasketDialog(self.state)
self.initialize()
self.setSelectAll()
self.actionButton.setIcon(self.state.getActionIcon())
self.operation = OperationManager(self.state)
self.progressDialog = ProgressDialog(self.state)
self.summaryDialog = SummaryDialog()
self.connectMainSignals()
self.connectOperationSignals()
def browse_for_iso(self):
clean_iso_path, selected_filter = QFileDialog.getOpenFileName(self, "Select Clean Skyward Sword NTSC-U 1.0 ISO",
None, "Wii ISO Files (*.iso)")
if not clean_iso_path:
return
self.progress_dialog = ProgressDialog("Extracting Game Files", "Initializing...", 100)
self.progress_dialog.setAutoClose(True)
self.extract_thread = ExtractSetupThread(self.wit_manager, clean_iso_path, None)
self.extract_thread.update_total_steps.connect(lambda total_steps: self.progress_dialog.setMaximum(total_steps))
self.extract_thread.update_progress.connect(self.ui_progress_callback)
def on_complete():
self.progress_dialog.reset()
if self.randomize_after_iso_extract:
self.randomize()
self.extract_thread.extract_complete.connect(on_complete)
def on_error(msg):
self.progress_dialog.reset()
self.error_msg = QMessageBox.critical(self, "Error", msg)
self.extract_thread.error_abort.connect(on_error)
self.extract_thread.start()
def randomize(self):
if not self.randothread is None:
print('ERROR: tried to randomize multiple times at once!')
return
dry_run = self.options['dry-run']
if not (dry_run or self.wit_manager.actual_extract_already_exists()):
self.randomize_after_iso_extract = True
self.ask_for_clean_iso()
return
# make sure user can't mess with the options now
rando = Randomizer(self.options.copy())
if dry_run:
extra_steps = 1 # done
else:
extra_steps = 101 # wit create wbfs + done
self.progress_dialog = ProgressDialog("Randomizing", "Initializing...",
rando.get_total_progress_steps() + extra_steps)
self.randomizer_thread = RandomizerThread(rando, self.wit_manager, self.output_folder)
self.randomizer_thread.update_progress.connect(self.ui_progress_callback)
self.randomizer_thread.randomization_complete.connect(self.randomization_complete)
self.randomizer_thread.error_abort.connect(self.on_error)
self.randomizer_thread.start()
def run(self):
# Create the dialog (after translation) and keep reference
dlg = UnibasCostSurfaceDialog(self.iface)
# show the dialog
dlg.show()
dlg.init_controls()
# Run the dialog event loop
result = dlg.exec_()
dlg.close()
# See if OK was pressed
if result == 1:
settings = dlg.get_complete_settings()
prg = ProgressDialog(self.iface, settings)
prg.show()
prg.begin_analysis()
prg.exec_()
def __init__(self, parent=None, silence = False):
QtGui.QWidget.__init__(self, parent)
self.setupUi(self)
self.parent = parent
self._selectedGroups = []
self.state = StateManager(self)
self.lastState = self.state.state
self.state.silence = silence
if not silence:
self.searchButton.setIcon(KIcon("edit-find"))
self.statusUpdater = StatusUpdater()
self.basket = BasketDialog(self.state)
self.searchUsed = False
self.initializeInfoBox()
self.initialize()
self.updateSettings()
self.actionButton.setIcon(self.state.getActionIcon())
self.connectMainSignals()
self.operation = OperationManager(self.state)
self.progressDialog = ProgressDialog(self.state)
self.summaryDialog = SummaryDialog()
self.connectOperationSignals()
def run(self):
self.emit('started', len(self.args))
for index, arg in enumerate(self.args):
if self.stopit is True:
break
self.emit('started_one', arg)
self.callback(arg)
self.emit('done_one', arg)
self.emit('ended', self.ok)
if __name__ == '__main__':
from progressdialog import ProgressDialog
def test(arg):
def feed(self, astring):
print(arg)
commands = ['ls', 'ls -la', 'ls']
diib = DoItInBackground(test, commands)
progreso = ProgressDialog('Adding new ppa', None)
progreso.set_number_of_elements(len(commands))
diib.connect('started_one', progreso.set_element)
# diib.connect('done_one', progreso.increase)
diib.connect('ended', progreso.close)
progreso.connect('i-want-stop', diib.stop)
diib.start()
progreso.run()
time.sleep(10)
def __init__(self, app = None, packages = [], hide_summary = False):
QDialog.__init__(self, None)
self.setupUi(self)
self.hide_summary = hide_summary
self.state = StateManager(self)
self.iface = self.state.iface
self.state._selected_packages = packages
self._packages = packages[:]
self._started = False
self._postexceptions = [lambda: sys.exit(1)]
# Check if another pisi instance already running
if isPisiRunning():
self.exceptionCaught("ALREADY RUNNING", block = True)
# Check given package names available in repositories
if not any(package.endswith('.pisi') for package in packages):
available_packages = self.state.packages()
for package in packages:
if package not in available_packages:
self.exceptionCaught('HTTP Error 404', package, block = True)
# Check if local/remote packages mixed with repo packages
# which pisi does not support to handle these at the same time
else:
if not all(package.endswith('.pisi') for package in packages):
self.exceptionCaught('MIXING PACKAGES', block = True)
# Check given local packages if exists
for package in get_real_paths(packages):
if '://' not in package and package.endswith('.pisi'):
if not os.path.exists(package):
self.exceptionCaught('FILE NOT EXISTS', package, block = True)
self.state.state = StateManager.INSTALL
# Get a list of package names from given args.
# It may include a path to local package, a path to remote package
# or just a package name; following crypted code will remove
# remote paths, appends package name as is and uses the pisi.api
# to get package name from given local package path.
#
# Example:
# input : ['/tmp/ax-2.3-1.pisi', 'http://pardus.org.tr/tt-2.3.pisi', 'yali']
# output: ['ax', 'yali']
_pkgs = map(lambda x: pisi.api.info_file(x)[0].package.name \
if x.endswith('.pisi') \
else x, filter(lambda x: '://' not in x,
get_real_paths(self.state._selected_packages)))
_pkgs = filter(lambda x: self.iface.pdb.has_package(x), _pkgs)
extras = self.state.iface.getExtras(_pkgs, self.state.state)
if extras:
self.state._selected_packages.extend(extras)
self.model = PackageModel(self)
self.model.setCheckable(False)
proxy = PackageProxy(self)
proxy.setSourceModel(self.model)
self.packageList.setModel(proxy)
self.packageList.setPackages(packages)
self.packageList.selectAll(packages)
self.packageList.setItemDelegate(PackageDelegate(self, self, showDetailsButton=False))
self.packageList.setColumnWidth(0, 32)
self.packageList.hideSelectAll()
self.operation = OperationManager(self.state)
self.progressDialog = ProgressDialog(self.state, self)
self.summaryDialog = SummaryDialog()
self.connectOperationSignals()
self.button_install.clicked.connect(self.installPackages)
self.button_install.setIcon(KIcon("list-add"))
self.button_cancel.clicked.connect(self.actionCancelled)
self.button_cancel.setIcon(KIcon("dialog-cancel"))
self.rejected.connect(self.actionCancelled)
class MainWidget(QWidget, PM, Ui_MainWidget):
# Signal Emits
updatingStatus = pyqtSignal()
repositoriesUpdated = pyqtSignal()
selectionStatusChanged = pyqtSignal([str])
finished = pyqtSignal()
cleanUp = pyqtSignal()
def __init__(self, parent = None):
super(MainWidget, self).__init__(parent)
self.setupUi(self)
self.parent = parent
self._selectedGroups = []
self._preexceptions = []
self._postexceptions = []
self.state = StateManager(self)
self.currentState = None
self.completer = None
self._updatesCheckedOnce = False
# Search Thread
self._searchThread = PThread(self, self.startSearch, self.searchFinished)
self.statusUpdater = StatusUpdater()
self.basket = BasketDialog(self.state, self.parent)
self._postexceptions.append(lambda: self.basket.setActionEnabled(True))
self.searchButton.setIcon(KIcon(("edit-find", "find")))
self.initializeUpdateTypeList()
model = PackageModel(self)
proxy = PackageProxy(self)
proxy.setSourceModel(model)
self.packageList.setModel(proxy)
self.packageList.setItemDelegate(PackageDelegate(self, self.parent))
self.packageList.setColumnWidth(0, 32)
self.packageList.dataChanged[QModelIndex,QModelIndex].connect(self.statusChanged)
self.packageList.updateRequested.connect(self.initialize)
self.updateSettings()
self.setActionButton()
self.operation = OperationManager(self.state)
self.progressDialog = ProgressDialog(self.state, self.parent)
self._preexceptions.append(self.progressDialog._hide)
self.progressDialog.registerFunction(FINISHED, lambda: self.parent.statusBar().setVisible(not self.progressDialog.isVisible()))
self.progressDialog.registerFunction(OUT, lambda: self.parent.statusBar().show())
self.summaryDialog = SummaryDialog()
self.connectOperationSignals()
self.pdsMessageBox = PMessageBox(self.content)
def connectMainSignals(self):
self.actionButton.clicked.connect(self.showBasket)
self.checkUpdatesButton.clicked.connect(self.state.updateRepoAction)
self.searchButton.clicked.connect(self.searchActivated)
self.searchLine.textEdited[str].connect(self.searchLineChanged)
self.searchLine.returnPressed.connect(self.searchActivated)
self.searchLine.textChanged[str].connect(self.slotSearchLineClear)
self.typeCombo.activated[int].connect(self.typeFilter)
self.stateTab.currentChanged[int].connect(self.switchState)
self.groupList.groupChanged.connect(self.groupFilter)
self.groupList.groupChanged.connect(lambda:self.searchButton.setEnabled(False))
self.packageList.select_all.clicked[bool].connect(self.toggleSelectAll)
self.packageList.itemDelegate().packageSelected[bool].connect(self.toggleSelect)
self.statusUpdater.selectedInfoChanged[int,str,int,str].connect(self.emitStatusBarInfo)
self.statusUpdater.selectedInfoChanged[str].connect(lambda message: self.selectionStatusChanged[str].emit(message))
self.statusUpdater.finished.connect(self.statusUpdated)
def initialize(self):
waitCursor()
self.searchLine.clear()
self._started = False
self._last_packages = None
self.state.reset()
self.initializePackageList()
self.initializeGroupList()
self.initializeStatusUpdater()
self.statusChanged()
self._selectedGroups = []
self.packageList.select_all.setChecked(False)
self.initializeBasket()
self.searchLine.setFocus(True)
if self.currentState == self.state.UPGRADE:
if self.groupList.count() == 0:
QTimer.singleShot(0, \
lambda: self.pdsMessageBox.showMessage(_translate("Packaga Manager","All packages are up to date"), icon = "info"))
if self.groupList.count() > 0:
if self.state.inUpgrade():
self.pdsMessageBox.hideMessage(force = True)
restoreCursor()
def initializeStatusUpdater(self):
self.statusUpdater.calculate_deps = not self.state.state == self.state.ALL
self.statusUpdater.setModel(self.packageList.model().sourceModel())
def initializeBasket(self):
waitCursor()
self.basket.setModel(self.packageList.model().sourceModel())
restoreCursor()
def initializePackageList(self):
self.packageList.model().reset()
self.packageList.setPackages(self.state.packages())
if self.completer:
self.completer.deleteLater()
del self.completer
self.completer = QCompleter(self.state.allPackages(), self)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.searchLine.setCompleter(self.completer)
def selectComponent(self, component):
if not self.state.iface.operationInProgress():
if self.basket.isVisible():
self.basket._hide()
self.stateTab.setCurrentIndex(1)
self.switchState(self.state.INSTALL)
if component in self.groupList._list:
self.groupList.setCurrentItem(self.groupList._list[component])
self.groupFilter()
def updateSettings(self): # pmconfig ikinci kez okunmuyor
self.packageList.showComponents = PMConfig().showComponents()
self.packageList.showIsA = PMConfig().showIsA()
self.packageList.setFocus()
self.initialize()
def searchLineChanged(self, text):
self.searchButton.setEnabled(bool(text))
if text == '':
self.searchActivated()
def statusUpdated(self):
if self.statusUpdater.needsUpdate:
self.statusUpdater.needsUpdate = False
self.statusChanged()
def statusChanged(self):
self.setActionEnabled()
if self.statusUpdater.isRunning():
self.statusUpdater.needsUpdate = True
else:
self.updatingStatus.emit()
self.statusUpdater.start()
def initializeGroupList(self):
self.groupList.clear()
self.groupList._list = {}
self.groupList.setAlternatingRowColors(True)
self.groupList.setIconSize(QSize(32, 32))
self.groupList.setState(self.state)
self.groupList.addGroups(self.state.groups())
if self.state.state == self.state.UPGRADE:
self.typeCombo.show()
else:
self.typeCombo.hide()
self.state._typeFilter = 'normal'
self.groupFilter()
def packageFilter(self, text):
self.packageList.model().setFilterRole(Qt.DisplayRole)
self.packageList.model().setFilterRegExp(QRegExp(unicode(text), Qt.CaseInsensitive, QRegExp.FixedString))
def typeFilter(self, index):
if self.state.state == self.state.UPGRADE:
filter = self.typeCombo.itemData(index)
if not self.state._typeFilter == filter:
self.state._typeFilter = filter
self.initializeGroupList()
def slotSearchLineClear(self):
if self.searchLine.text()!="":
return
self.groupFilter()
def groupFilter(self):
waitCursor()
self.packageList.resetMoreInfoRow()
packages = self.state.groupPackages(self.groupList.currentGroup())
self.packageList.model().setFilterRole(GroupRole)
self.packageList.model().setFilterPackages(packages)
self.packageList.scrollToTop()
self.packageList.select_all.setChecked(self.groupList.currentGroup() in self._selectedGroups)
restoreCursor()
def searchActivated(self):
if self.currentState == self.state.UPGRADE:
if self.groupList.count() == 0 and not self.searchUsed:
return
if not self.searchLine.text() == '':
self.pdsMessageBox.showMessage(_translate("Packaga Manager","Searching..."), busy = True)
self.groupList.lastSelected = None
self._searchThread.start()
self.searchUsed = True
else:
self.state.cached_packages = None
self.state.packages()
self.searchUsed = False
self.searchFinished()
def searchFinished(self):
if self.state.cached_packages == []:
self.pdsMessageBox.showMessage(_translate("Packaga Manager","No results found."), "dialog-information")
else:
self.pdsMessageBox.hideMessage()
self.initializeGroupList()
self.initializePackageList()
def startSearch(self):
searchText = str(self.searchLine.text()).split()
sourceModel = self.packageList.model().sourceModel()
self.state.cached_packages = sourceModel.search(searchText)
self.finished.emit()
return self.state.cached_packages
def setActionButton(self):
self.actionButton.setEnabled(False)
if self.state.state == self.state.ALL:
menu = QMenu(self.actionButton)
self.__install_action = menu.addAction(self.state.getActionIcon(self.state.INSTALL),
self.state.getActionName(self.state.INSTALL),
self.showBasket)
self.__remove_action = menu.addAction(self.state.getActionIcon(self.state.REMOVE),
self.state.getActionName(self.state.REMOVE),
self.showBasket)
self.actionButton.setMenu(menu)
else:
self.actionButton.setMenu(None)
self.actionButton.setIcon(self.state.getActionIcon())
self.actionButton.setText(self.state.getActionName())
def actionStarted(self, operation):
self.pdsMessageBox.hideMessage()
self.progressDialog.reset()
if not operation in ["System.Manager.updateRepository", "System.Manager.updateAllRepositories"]:
totalPackages = self.packageList.packageCount()
self.operation.setTotalPackages(totalPackages)
self.progressDialog.updateStatus(0, totalPackages, self.state.toBe())
if self.isVisible():
if operation in ["System.Manager.updateRepository", "System.Manager.updateAllRepositories"]:
self.progressDialog.repoOperationView()
if self.basket.isVisible():
self.basket._hide()
QTimer.singleShot(0, self.progressDialog._show)
else:
self.progressDialog._show()
if not self._started:
self.progressDialog.disableCancel()
else:
self.progressDialog.enableCancel()
def actionFinished(self, operation):
if operation in ("System.Manager.installPackage",
"System.Manager.removePackage",
"System.Manager.updatePackage"):
self.notifyFinished()
if operation == "System.Manager.installPackage" and self._started:
KIconLoader.updateAvailableIcons()
self.summaryDialog.setDesktopFiles(self.operation.desktopFiles)
self.summaryDialog.showSummary()
if operation in ("System.Manager.updateRepository",
"System.Manager.updateAllRepositories"):
self.repositoriesUpdated.emit()
self.searchLine.clear()
self.state.reset()
self.progressDialog._hide()
if not self.currentState == self.state.UPGRADE:
self.switchState(self.currentState)
self.initialize()
def actionCancelled(self):
self.progressDialog._hide()
self.progressDialog.reset()
self.switchState(self.currentState)
self.groupFilter()
def setActionEnabled(self):
enabled = self.packageList.isSelected()
self.actionButton.setEnabled(enabled)
self.basket.setActionEnabled(enabled)
def switchState(self, state):
self.pdsMessageBox.hideMessage()
self._states[state][1].setChecked(True)
self.state.setState(state)
self.currentState = state
self._selectedGroups = []
if not state == self.state.HISTORY:
self.setActionButton()
self.state.cached_packages = None
if state == self.state.UPGRADE or (state == self.state.INSTALL and self.groupList.count() == 1):
if not self._updatesCheckedOnce:
self._updatesCheckedOnce = self.state.updateRepoAction(silence = True)
self.checkUpdatesButton.setHidden(not state == self.state.UPGRADE)
self.initialize()
def emitStatusBarInfo(self, packages, packagesSize, extraPackages, extraPackagesSize):
self.selectionStatusChanged[str].emit(self.state.statusText(packages, packagesSize, extraPackages, extraPackagesSize))
# paket seçimine geçici çözüm
if packages > 0:
self.actionButton.setEnabled(True)
else:
self.actionButton.setEnabled(False)
def setSelectAll(self, packages=None):
if packages:
self.packageList.reverseSelection(packages)
def setReverseAll(self, packages=None):
if packages:
self.packageList.selectAll(packages)
def toggleSelectAll(self, toggled):
self._last_packages = self.packageList.model().getFilteredPackages()
if toggled:
if self.groupList.currentGroup() not in self._selectedGroups:
self._selectedGroups.append(self.groupList.currentGroup())
self.setReverseAll(self._last_packages)
else:
if self.groupList.currentGroup() in self._selectedGroups:
self._selectedGroups.remove(self.groupList.currentGroup())
self.setSelectAll(self._last_packages)
self.packageList.setFocus()
self.statusChanged()
def toggleSelect(self, toggled):
#self._last_packages = self.packageList.model().getFilteredPackages()
if toggled:
if self.groupList.currentGroup() not in self._selectedGroups:
self._selectedGroups.append(self.groupList.currentGroup())
#else:
#if self.groupList.currentGroup() in self._selectedGroups:
# self._selectedGroups.remove(self.groupList.currentGroup())
#self.setSelectAll(self._last_packages)
self.packageList.setFocus()
self.statusChanged()
def showBasket(self):
if self.basket.isVisible():
return
waitCursor()
self.statusUpdater.wait()
if self.currentState == self.state.ALL:
action = {self.__remove_action:self.state.REMOVE,
self.__install_action:self.state.INSTALL}.get(self.sender(), self.state.INSTALL)
if action:
if action == self.state.REMOVE:
installed_packages = self.state.iface.getInstalledPackages()
filtered_packages = filter(lambda x: x not in installed_packages, self.basket.model.selectedPackages())
if filtered_packages == self.basket.model.selectedPackages():
restoreCursor()
QMessageBox(_translate("Packaga Manager","Select packages"),
_translate("Packaga Manager","You must select at least one installed package"),
QMessageBox.Information, QMessageBox.Ok, 0, 0).exec_()
return
self.packageList.model().sourceModel().selectPackages(filtered_packages, state = False)
self.state.state = action
self.basket._show()
restoreCursor()
def initializeUpdateTypeList(self):
self.typeCombo.clear()
UPDATE_TYPES = [['normal', _translate("Packaga Manager",'All Updates'), ('system-software-update', 'ledgreen')],
['security', _translate("Packaga Manager",'Security Updates'), ('security-medium', 'ledyellow')],
['critical', _translate("Packaga Manager",'Critical Updates'), ('security-low', 'ledred')]]
for type in UPDATE_TYPES:
self.typeCombo.addItem(KIcon(type[2]), type[1], QVariant(type[0]))
def __init__(self, app=None, packages=[], hide_summary=False):
QDialog.__init__(self, None)
self.setupUi(self)
self.hide_summary = hide_summary
self.state = StateManager(self)
self.iface = self.state.iface
self.state._selected_packages = packages
self._packages = packages[:]
self._started = False
self._postexceptions = [lambda: sys.exit(1)]
# Check if another pisi instance already running
if isPisiRunning():
self.exceptionCaught("ALREADY RUNNING", block=True)
# Check given package names available in repositories
if not any(package.endswith('.pisi') for package in packages):
available_packages = self.state.packages()
for package in packages:
if package not in available_packages:
self.exceptionCaught('HTTP Error 404', package, block=True)
# Check if local/remote packages mixed with repo packages
# which pisi does not support to handle these at the same time
else:
if not all(package.endswith('.pisi') for package in packages):
self.exceptionCaught('MIXING PACKAGES', block=True)
# Check given local packages if exists
for package in get_real_paths(packages):
if '://' not in package and package.endswith('.pisi'):
if not os.path.exists(package):
self.exceptionCaught('FILE NOT EXISTS',
package,
block=True)
self.state.state = StateManager.INSTALL
# Get a list of package names from given args.
# It may include a path to local package, a path to remote package
# or just a package name; following crypted code will remove
# remote paths, appends package name as is and uses the pisi.api
# to get package name from given local package path.
#
# Example:
# input : ['/tmp/ax-2.3-1.pisi', 'http://pardus.org.tr/tt-2.3.pisi', 'yali']
# output: ['ax', 'yali']
_pkgs = map(lambda x: pisi.api.info_file(x)[0].package.name \
if x.endswith('.pisi') \
else x, filter(lambda x: '://' not in x,
get_real_paths(self.state._selected_packages)))
_pkgs = filter(lambda x: self.iface.pdb.has_package(x), _pkgs)
extras = self.state.iface.getExtras(_pkgs, self.state.state)
if extras:
self.state._selected_packages.extend(extras)
self.model = PackageModel(self)
self.model.setCheckable(False)
proxy = PackageProxy(self)
proxy.setSourceModel(self.model)
self.packageList.setModel(proxy)
self.packageList.setPackages(packages)
self.packageList.selectAll(packages)
self.packageList.setItemDelegate(
PackageDelegate(self, self, showDetailsButton=False))
self.packageList.setColumnWidth(0, 32)
self.packageList.hideSelectAll()
self.operation = OperationManager(self.state)
self.progressDialog = ProgressDialog(self.state, self)
self.summaryDialog = SummaryDialog()
self.connectOperationSignals()
self.button_install.clicked.connect(self.installPackages)
self.button_install.setIcon(KIcon(("list-add", "add")))
self.button_cancel.clicked.connect(self.actionCancelled)
self.button_cancel.setIcon(KIcon("cancel"))
self.rejected.connect(self.actionCancelled)
class PmWindow(QDialog, PM, Ui_PmWindow):
def __init__(self, app = None, packages = [], hide_summary = False):
QDialog.__init__(self, None)
self.setupUi(self)
self.hide_summary = hide_summary
self.state = StateManager(self)
self.iface = self.state.iface
self.state._selected_packages = packages
self._packages = packages[:]
self._started = False
self._postexceptions = [lambda: sys.exit(1)]
# Check if another pisi instance already running
if isPisiRunning():
self.exceptionCaught("ALREADY RUNNING", block = True)
# Check given package names available in repositories
if not any(package.endswith('.pisi') for package in packages):
available_packages = self.state.packages()
for package in packages:
if package not in available_packages:
self.exceptionCaught('HTTP Error 404', package, block = True)
# Check if local/remote packages mixed with repo packages
# which pisi does not support to handle these at the same time
else:
if not all(package.endswith('.pisi') for package in packages):
self.exceptionCaught('MIXING PACKAGES', block = True)
# Check given local packages if exists
for package in get_real_paths(packages):
if '://' not in package and package.endswith('.pisi'):
if not os.path.exists(package):
self.exceptionCaught('FILE NOT EXISTS', package, block = True)
self.state.state = StateManager.INSTALL
# Get a list of package names from given args.
# It may include a path to local package, a path to remote package
# or just a package name; following crypted code will remove
# remote paths, appends package name as is and uses the pisi.api
# to get package name from given local package path.
#
# Example:
# input : ['/tmp/ax-2.3-1.pisi', 'http://pardus.org.tr/tt-2.3.pisi', 'yali']
# output: ['ax', 'yali']
_pkgs = map(lambda x: pisi.api.info_file(x)[0].package.name \
if x.endswith('.pisi') \
else x, filter(lambda x: '://' not in x,
get_real_paths(self.state._selected_packages)))
_pkgs = filter(lambda x: self.iface.pdb.has_package(x), _pkgs)
extras = self.state.iface.getExtras(_pkgs, self.state.state)
if extras:
self.state._selected_packages.extend(extras)
self.model = PackageModel(self)
self.model.setCheckable(False)
proxy = PackageProxy(self)
proxy.setSourceModel(self.model)
self.packageList.setModel(proxy)
self.packageList.setPackages(packages)
self.packageList.selectAll(packages)
self.packageList.setItemDelegate(PackageDelegate(self, self, showDetailsButton=False))
self.packageList.setColumnWidth(0, 32)
self.packageList.hideSelectAll()
self.operation = OperationManager(self.state)
self.progressDialog = ProgressDialog(self.state, self)
self.summaryDialog = SummaryDialog()
self.connectOperationSignals()
self.button_install.clicked.connect(self.installPackages)
self.button_install.setIcon(KIcon("list-add"))
self.button_cancel.clicked.connect(self.actionCancelled)
self.button_cancel.setIcon(KIcon("dialog-cancel"))
self.rejected.connect(self.actionCancelled)
def reject(self):
if self.iface.operationInProgress() and self._started:
return
QDialog.reject(self)
def installPackages(self):
reinstall = False
answer = True
self.button_install.setEnabled(False)
actions = self.state.checkInstallActions(self.model.selectedPackages())
if actions:
answer = askForActions(actions,
i18n("Selected packages are already installed.<br>"
"If you continue, the packages will be reinstalled"),
i18n("Already Installed Packages"),
i18n("Installed Packages"))
if not answer:
self.button_install.setEnabled(True)
return
if actions:
reinstall = True
connection_required = True
if isAllLocal(self.model.selectedPackages()):
connection_required = False
operation = self.state.operationAction(self._packages,
reinstall = reinstall,
silence = True,
connection_required = connection_required)
self._started = True
if operation == False:
sys.exit(1)
def actionStarted(self, operation):
totalPackages = len(self.state._selected_packages)
self.progressDialog.reset()
if not operation in ["System.Manager.updateRepository", "System.Manager.updateAllRepositories"]:
self.operation.setTotalPackages(totalPackages)
self.progressDialog.updateStatus(0, totalPackages, self.state.toBe())
self.progressDialog._show()
if not self._started:
self.progressDialog.disableCancel()
else:
self.progressDialog.enableCancel()
def actionFinished(self, operation):
if operation in ("System.Manager.installPackage",
"System.Manager.removePackage",
"System.Manager.updatePackage"):
self.notifyFinished()
if operation == "System.Manager.installPackage" and not self.hide_summary:
self.summaryDialog.setDesktopFiles(self.operation.desktopFiles)
self.summaryDialog.showSummary()
self.hide()
if not self.summaryDialog.hasApplication():
# Package install succesfull return value is 0
QTimer.singleShot(10, lambda: sys.exit(0))
def actionCancelled(self):
# Package install failed with user cancel, return value is 3
sys.exit(3)
class PmWindow(QDialog, PM, Ui_PmWindow):
def __init__(self, app=None, packages=[], hide_summary=False):
QDialog.__init__(self, None)
self.setupUi(self)
self.hide_summary = hide_summary
self.state = StateManager(self)
self.iface = self.state.iface
self.state._selected_packages = packages
self._packages = packages[:]
self._started = False
self._postexceptions = [lambda: sys.exit(1)]
# Check if another pisi instance already running
if isPisiRunning():
self.exceptionCaught("ALREADY RUNNING", block=True)
# Check given package names available in repositories
if not any(package.endswith('.pisi') for package in packages):
available_packages = self.state.packages()
for package in packages:
if package not in available_packages:
self.exceptionCaught('HTTP Error 404', package, block=True)
# Check if local/remote packages mixed with repo packages
# which pisi does not support to handle these at the same time
else:
if not all(package.endswith('.pisi') for package in packages):
self.exceptionCaught('MIXING PACKAGES', block=True)
# Check given local packages if exists
for package in get_real_paths(packages):
if '://' not in package and package.endswith('.pisi'):
if not os.path.exists(package):
self.exceptionCaught('FILE NOT EXISTS',
package,
block=True)
self.state.state = StateManager.INSTALL
# Get a list of package names from given args.
# It may include a path to local package, a path to remote package
# or just a package name; following crypted code will remove
# remote paths, appends package name as is and uses the pisi.api
# to get package name from given local package path.
#
# Example:
# input : ['/tmp/ax-2.3-1.pisi', 'http://pardus.org.tr/tt-2.3.pisi', 'yali']
# output: ['ax', 'yali']
_pkgs = map(lambda x: pisi.api.info_file(x)[0].package.name \
if x.endswith('.pisi') \
else x, filter(lambda x: '://' not in x,
get_real_paths(self.state._selected_packages)))
_pkgs = filter(lambda x: self.iface.pdb.has_package(x), _pkgs)
extras = self.state.iface.getExtras(_pkgs, self.state.state)
if extras:
self.state._selected_packages.extend(extras)
self.model = PackageModel(self)
self.model.setCheckable(False)
proxy = PackageProxy(self)
proxy.setSourceModel(self.model)
self.packageList.setModel(proxy)
self.packageList.setPackages(packages)
self.packageList.selectAll(packages)
self.packageList.setItemDelegate(
PackageDelegate(self, self, showDetailsButton=False))
self.packageList.setColumnWidth(0, 32)
self.packageList.hideSelectAll()
self.operation = OperationManager(self.state)
self.progressDialog = ProgressDialog(self.state, self)
self.summaryDialog = SummaryDialog()
self.connectOperationSignals()
self.button_install.clicked.connect(self.installPackages)
self.button_install.setIcon(KIcon(("list-add", "add")))
self.button_cancel.clicked.connect(self.actionCancelled)
self.button_cancel.setIcon(KIcon("cancel"))
self.rejected.connect(self.actionCancelled)
def reject(self):
if self.iface.operationInProgress() and self._started:
return
QDialog.reject(self)
def installPackages(self):
reinstall = False
answer = True
self.button_install.setEnabled(False)
actions = self.state.checkInstallActions(self.model.selectedPackages())
if actions:
answer = askForActions(
actions,
i18n("Selected packages are already installed.<br>"
"If you continue, the packages will be reinstalled"),
i18n("Already Installed Packages"), i18n("Installed Packages"))
if not answer:
self.button_install.setEnabled(True)
return
if actions:
reinstall = True
connection_required = True
if isAllLocal(self.model.selectedPackages()):
connection_required = False
operation = self.state.operationAction(
self._packages,
reinstall=reinstall,
silence=True,
connection_required=connection_required)
self._started = True
if operation == False:
sys.exit(1)
def actionStarted(self, operation):
totalPackages = len(self.state._selected_packages)
self.progressDialog.reset()
if not operation in [
"System.Manager.updateRepository",
"System.Manager.updateAllRepositories"
]:
self.operation.setTotalPackages(totalPackages)
self.progressDialog.updateStatus(0, totalPackages,
self.state.toBe())
self.progressDialog._show()
if not self._started:
self.progressDialog.disableCancel()
else:
self.progressDialog.enableCancel()
def actionFinished(self, operation):
if operation in ("System.Manager.installPackage",
"System.Manager.removePackage",
"System.Manager.updatePackage"):
self.notifyFinished()
if operation == "System.Manager.installPackage" and not self.hide_summary:
self.summaryDialog.setDesktopFiles(self.operation.desktopFiles)
self.summaryDialog.showSummary()
self.hide()
if not self.summaryDialog.hasApplication():
# Package install succesfull return value is 0
QTimer.singleShot(10, lambda: sys.exit(0))
def actionCancelled(self):
# Package install failed with user cancel, return value is 3
sys.exit(3)
class RandoGUI(QMainWindow):
def __init__(self):
super().__init__()
self.wit_manager = WitManager(Path('.').resolve())
self.randothread = None
self.error_msg = None
self.progress_dialog = None
self.randomize_after_iso_extract = False
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.setWindowTitle("Skyward Sword Randomizer v"+VERSION)
self.output_folder = ""
self.options = Options()
self.option_map = {}
for option_key, option in OPTIONS.items():
if option["name"] != "Banned Types" and option["name"] != "Seed":
ui_name = option.get('ui', None)
self.option_map[ui_name] = option
if not ui_name:
continue
widget = getattr(self.ui, ui_name)
widget.installEventFilter(self)
if isinstance(widget, QAbstractButton):
widget.setChecked(self.options[option_key])
widget.clicked.connect(self.update_settings)
elif isinstance(widget, QComboBox):
widget.clicked.connect(self.update_settings)
elif isinstance(widget, QListView):
pass
elif isinstance(widget, QSpinBox):
if 'min' in option:
widget.setMinimum(option['min'])
if 'max' in option:
widget.setMaximum(option['max'])
widget.setValue(self.options[option_key])
widget.valueChanged.connect(self.update_settings)
self.location_descriptions = {
"batreaux": "Enables progression items to appear as rewards from giving Gratitude Crystals to Batreaux",
"crystal": "Enables progression items to appear as loose crystals (currently not randomized and must "
"always be enabled)",
"dungeon": "Enables progression items to appear in dungeons",
"goddess": "Enables progression items to appear as items in Goddess Chests",
"minigame": "Enables progression items to appear as rewards from winning minigames",
"overworld": "Enables progression items to appear in the overworld",
"quest": "Enables progression items to appear as rewards from the main quest events (i.e. in place of the "
"shield from Professor Owlan)",
"sidequest": "Enables progression items to appear as rewards from completing gratitude crystal quests",
"silent_realm": "Enables progression items to appear as rewards for completing Silent Realm trials",
"peatrice": "Enables progression items to appear as rewards for Peatrice's sidequest",
"scrapper": "Enables progression items to appear as rewards for Scrapper Quests"
}
for check_type in ALL_TYPES:
widget = getattr(self.ui, "progression_" + check_type.replace(" ", "_"))
widget.setChecked(not check_type in self.options['banned-types'])
if check_type == 'crystal':
widget.setEnabled(False)
widget.clicked.connect(self.update_settings)
widget.installEventFilter(self)
self.ui.ouput_folder_browse_button.clicked.connect(self.browse_for_output_dir)
self.ui.randomize_button.clicked.connect(self.randomize)
self.ui.permalink.textChanged.connect(self.permalink_updated)
self.ui.seed.textChanged.connect(self.update_settings)
self.update_ui_for_settings()
self.set_option_description(None)
if not self.wit_manager.actual_extract_already_exists():
self.ask_for_clean_iso()
def ask_for_clean_iso(self):
selected = QMessageBox.question(self, 'Extract now?',
'For randomizing purposes, a clean NTSC-U 1.00 ISO is needed, browse for it now? This is only needed once',
defaultButton=QMessageBox.Yes)
if selected == QMessageBox.Yes:
self.browse_for_iso()
else:
self.randomize_after_iso_extract = False
def randomize(self):
if not self.randothread is None:
print('ERROR: tried to randomize multiple times at once!')
return
dry_run = self.options['dry-run']
if not (dry_run or self.wit_manager.actual_extract_already_exists()):
self.randomize_after_iso_extract = True
self.ask_for_clean_iso()
return
# make sure user can't mess with the options now
rando = Randomizer(self.options.copy())
if dry_run:
extra_steps = 1 # done
else:
extra_steps = 101 # wit create wbfs + done
self.progress_dialog = ProgressDialog("Randomizing", "Initializing...",
rando.get_total_progress_steps() + extra_steps)
self.randomizer_thread = RandomizerThread(rando, self.wit_manager, self.output_folder)
self.randomizer_thread.update_progress.connect(self.ui_progress_callback)
self.randomizer_thread.randomization_complete.connect(self.randomization_complete)
self.randomizer_thread.error_abort.connect(self.on_error)
self.randomizer_thread.start()
def ui_progress_callback(self, current_action, completed_steps, total_steps=None):
self.progress_dialog.setValue(completed_steps)
self.progress_dialog.setLabelText(current_action)
if not total_steps is None:
self.progress_dialog.setMaximum(total_steps)
def on_error(self, message):
self.error_msg = QErrorMessage(self)
self.error_msg.showMessage(message)
def randomization_complete(self):
self.progress_dialog.reset()
text = """Randomization complete.<br><br>
If you get stuck, check the progression spoiler log in the output folder."""
self.complete_dialog = QMessageBox()
self.complete_dialog.setTextFormat(Qt.TextFormat.RichText)
self.complete_dialog.setWindowTitle("Randomization complete")
self.complete_dialog.setText(text)
self.complete_dialog.setWindowIcon(self.windowIcon())
self.complete_dialog.show()
self.randomizer_thread = None
def browse_for_iso(self):
clean_iso_path, selected_filter = QFileDialog.getOpenFileName(self, "Select Clean Skyward Sword NTSC-U 1.0 ISO",
None, "Wii ISO Files (*.iso)")
if not clean_iso_path:
return
self.progress_dialog = ProgressDialog("Extracting Game Files", "Initializing...", 100)
self.progress_dialog.setAutoClose(True)
self.extract_thread = ExtractSetupThread(self.wit_manager, clean_iso_path, None)
self.extract_thread.update_total_steps.connect(lambda total_steps: self.progress_dialog.setMaximum(total_steps))
self.extract_thread.update_progress.connect(self.ui_progress_callback)
def on_complete():
self.progress_dialog.reset()
if self.randomize_after_iso_extract:
self.randomize()
self.extract_thread.extract_complete.connect(on_complete)
def on_error(msg):
self.progress_dialog.reset()
self.error_msg = QMessageBox.critical(self, "Error", msg)
self.extract_thread.error_abort.connect(on_error)
self.extract_thread.start()
def browse_for_output_dir(self):
if self.output_folder and os.path.isfile(self.output_folder):
default_dir = os.path.dirname(self.output_folder)
else:
default_dir = None
output_folder = QFileDialog.getExistingDirectory(self, "Select output folder", default_dir)
if not output_folder:
return
self.ui.output_folder.setText(output_folder)
self.update_settings()
def update_ui_for_settings(self):
self.ui.output_folder.setText(self.output_folder)
self.ui.seed.setText(str(self.options["seed"]))
self.ui.permalink.setText(self.options.get_permalink())
for option_key, option in OPTIONS.items():
if option["name"] != "Banned Types" and option["name"] != "Seed":
ui_name = option.get('ui', None)
if not ui_name:
continue
widget = getattr(self.ui, ui_name)
if isinstance(widget, QAbstractButton):
widget.setChecked(self.options[option_key])
elif isinstance(widget, QComboBox):
pass
elif isinstance(widget, QListView):
pass
elif isinstance(widget, QSpinBox):
widget.setValue(self.options[option_key])
getattr(self.ui, f"label_for_{ui_name}").installEventFilter(self)
for check_type in ALL_TYPES:
widget = getattr(self.ui, "progression_" + check_type.replace(" ", "_"))
widget.setChecked(not check_type in self.options['banned-types'])
def update_settings(self):
self.output_folder = self.ui.output_folder.text()
try:
self.options.set_option("seed", int(self.ui.seed.text()))
except ValueError:
if self.ui.seed.text() == "":
self.options.set_option("seed", -1)
else:
# TODO: give an error dialog or some sort of error message that the seed is invalid
pass
for option_command, option in OPTIONS.items():
if option["name"] != "Banned Types" and option["name"] != "Seed":
ui_name = option.get('ui', None)
if not ui_name:
continue
self.options.set_option(option_command, self.get_option_value(ui_name))
self.options.set_option("banned-types", self.get_banned_types())
self.ui.permalink.setText(self.options.get_permalink())
def get_option_value(self, option_name):
widget = getattr(self.ui, option_name)
if isinstance(widget, QCheckBox) or isinstance(widget, QRadioButton):
return widget.isChecked()
elif isinstance(widget, QComboBox):
return widget.itemText(widget.currentIndex())
elif isinstance(widget, QSpinBox):
return widget.value()
elif isinstance(widget, QListView):
pass
else:
print("Option widget is invalid: %s" % option_name)
def get_banned_types(self):
banned_types = []
for check_type in ALL_TYPES:
widget = getattr(self.ui, "progression_" + check_type.replace(" ", "_"))
if not widget.isChecked():
banned_types.append(check_type)
return banned_types
def eventFilter(self, target, event):
if event.type() == QEvent.Enter:
ui_name = target.objectName()
if ui_name.startswith("progression_"):
ui_name = ui_name[len("progression_"):]
self.set_option_description(self.location_descriptions[ui_name])
else:
if ui_name.startswith("label_for_"):
ui_name = ui_name[len("label_for_"):]
option = self.option_map[ui_name]
self.set_option_description(option["help"])
return True
elif event.type() == QEvent.Leave:
self.set_option_description(None)
return True
return QMainWindow.eventFilter(self, target, event)
def set_option_description(self, new_description):
if new_description is None:
self.ui.option_description.setText("(Hover over an option to see a description of what it does.)")
self.ui.option_description.setStyleSheet("color: grey;")
else:
self.ui.option_description.setText(new_description)
self.ui.option_description.setStyleSheet("")
def permalink_updated(self):
try:
self.options.update_from_permalink(self.ui.permalink.text())
except ValueError as e:
# Ignore errors from faultly permalinks, with updating ui it gets reset anyways
print(e)
except IndexError as e:
print(e)
self.update_ui_for_settings()
class MainWidget(QtGui.QWidget, Ui_MainWidget):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.setupUi(self)
self.searchButton.setIcon(KIcon("edit-find"))
self.statusUpdater = StatusUpdater()
self.state = StateManager(self)
self.basket = BasketDialog(self.state)
self.initialize()
self.setSelectAll()
self.actionButton.setIcon(self.state.getActionIcon())
self.operation = OperationManager(self.state)
self.progressDialog = ProgressDialog(self.state)
self.summaryDialog = SummaryDialog()
self.connectMainSignals()
self.connectOperationSignals()
def connectMainSignals(self):
self.connect(self.actionButton, SIGNAL("clicked()"), self.showBasket)
self.connect(self.searchButton, SIGNAL("clicked()"), self.searchActivated)
self.connect(self.searchLine, SIGNAL("textEdited(const QString&)"), self.searchLineChanged)
self.connect(self.searchLine, SIGNAL("returnPressed()"), self.searchActivated)
self.connect(self.searchLine, SIGNAL("clearButtonClicked()"), self.groupFilter)
self.connect(self.groupList, SIGNAL("groupChanged()"), self.groupFilter)
self.connect(self.groupList, SIGNAL("groupChanged()"), self.searchLine.clear)
self.connect(self.groupList, SIGNAL("groupChanged()"), lambda:self.searchButton.setEnabled(False))
self.connect(self.selectAll, SIGNAL("leftClickedUrl(const QString&)"), self.toggleSelectAll)
self.connect(self.statusUpdater, SIGNAL("selectedInfoChanged(int, QString, int, QString)"), self.emitStatusBarInfo)
self.connect(self.statusUpdater, SIGNAL("finished()"), self.statusUpdated)
def connectOperationSignals(self):
self.connect(self.operation, SIGNAL("exception(QString)"), self.exceptionCaught)
self.connect(self.operation, SIGNAL("finished(QString)"), self.actionFinished)
self.connect(self.operation, SIGNAL("started(QString)"), self.actionStarted)
self.connect(self.operation, SIGNAL("started(QString)"), self.progressDialog.updateActionLabel)
self.connect(self.operation, SIGNAL("operationCancelled()"), self.progressDialog.hide)
self.connect(self.operation, SIGNAL("progress(int)"), self.progressDialog.updateProgress)
self.connect(self.operation, SIGNAL("operationChanged(QString,QString)"), self.progressDialog.updateOperation)
self.connect(self.operation, SIGNAL("packageChanged(int, int, QString)"), self.progressDialog.updateStatus)
self.connect(self.operation, SIGNAL("elapsedTime(QString)"), self.progressDialog.updateRemainingTime)
self.connect(self.operation, SIGNAL("downloadInfoChanged(QString, QString, QString)"), self.progressDialog.updateCompletedInfo)
def initialize(self):
waitCursor()
self.state.reset()
self.initializePackageList()
self.initializeGroupList()
self.initializeBasket()
self.initializeStatusUpdater()
self.statusChanged()
restoreCursor()
def initializeStatusUpdater(self):
self.statusUpdater.setModel(self.packageList.model().sourceModel())
def initializeBasket(self):
self.basket.setModel(self.packageList.model().sourceModel())
def initializePackageList(self):
self.packageList.setModel(PackageProxy(self))
self.packageList.model().setSourceModel(PackageModel(self))
self.packageList.setItemDelegate(PackageDelegate(self))
self.packageList.setColumnWidth(0, 32)
self.packageList.setAlternatingRowColors(True)
self.packageList.setSelectionMode(QtGui.QAbstractItemView.MultiSelection)
self.packageList.setPackages(self.state.packages())
self.connect(self.packageList.model(), SIGNAL("dataChanged(QModelIndex,QModelIndex)"), self.statusChanged)
def searchLineChanged(self, text):
self.searchButton.setEnabled(bool(text))
def statusUpdated(self):
if self.statusUpdater.needsUpdate:
self.statusUpdater.needsUpdate = False
self.statusChanged()
def statusChanged(self):
self.setActionEnabled()
if self.statusUpdater.isRunning():
self.statusUpdater.needsUpdate = True
else:
self.emit(SIGNAL("updatingStatus()"))
self.statusUpdater.start()
def initializeGroupList(self):
self.groupList.clear()
self.groupList.setAlternatingRowColors(True)
self.groupList.setIconSize(QSize(KIconLoader.SizeLarge, KIconLoader.SizeLarge))
self.groupList.setState(self.state)
self.groupList.addGroups(self.state.groups())
self.groupFilter()
def packageFilter(self, text):
self.packageList.model().setFilterRole(Qt.DisplayRole)
self.packageList.model().setFilterRegExp(QRegExp(unicode(text), Qt.CaseInsensitive, QRegExp.FixedString))
def groupFilter(self):
self.setSelectAll()
self.packageList.resetMoreInfoRow()
packages = self.state.groupPackages(self.groupList.currentGroup())
self.packageList.model().setFilterRole(GroupRole)
waitCursor()
self.packageList.model().setFilterPackages(packages)
restoreCursor()
def searchActivated(self):
self.setSelectAll()
self.packageList.resetMoreInfoRow()
waitCursor()
packages = self.packageList.search(str(self.searchLine.text()).split())
self.packageList.model().setFilterRole(GroupRole)
self.packageList.model().setFilterPackages(packages)
restoreCursor()
def setActionButton(self):
self.actionButton.setEnabled(False)
self.actionButton.setText(self.state.getActionName())
self.actionButton.setIcon(self.state.getActionIcon())
def actionStarted(self, operation):
totalPackages = self.packageList.packageCount()
self.operation.setTotalPackages(totalPackages)
self.progressDialog.reset()
self.progressDialog.updateStatus(0, totalPackages, self.state.toBe())
if self.isVisible():
if operation in ["System.Manager.updateRepository", "System.Manager.updateAllRepositories"]:
self.progressDialog.repoOperationView()
self.progressDialog.show()
self.progressDialog.enableCancel()
def exceptionCaught(self, message):
self.progressDialog.hide()
if "urlopen error" in message or "Socket Error" in message:
errorTitle = i18n("Network Error")
errorMessage = i18n("Please check your network connections and try again.")
elif "Access denied" in message or "tr.org.pardus.comar.Comar.PolicyKit" in message:
errorTitle = i18n("Authorization Error")
errorMessage = i18n("You are not authorized for this operation.")
elif "HTTP Error 404":
errorTitle = i18n("Pisi Error")
errorMessage = i18n("Package not found. It may be upgraded in or removed from the repository. Please try upgrading repository informations.")
else:
errorTitle = i18n("Pisi Error")
errorMessage = message
self.messageBox = QtGui.QMessageBox(errorTitle, errorMessage, QtGui.QMessageBox.Critical, QtGui.QMessageBox.Ok, 0, 0)
self.messageBox.show()
def actionFinished(self, operation):
self.searchLine.clear()
self.state.reset()
self.progressDialog.hide()
if operation == "System.Manager.installPackage":
self.showSummary()
if operation in ["System.Manager.installPackage", "System.Manager.removePackage", "System.Manager.updatePackage"]:
self.notifyFinished()
self.initialize()
def notifyFinished(self):
# Since we can not identify the caller yet
if not self.operation.totalPackages:
return
KNotification.event("Summary",
self.state.getSummaryInfo(self.operation.totalPackages),
QtGui.QPixmap(),
None,
KNotification.CloseOnTimeout,
KComponentData("package-manager", "package-manager", KComponentData.SkipMainComponentRegistration)
)
def showSummary(self):
self.summaryDialog.setDesktopFiles(self.operation.desktopFiles)
if self.summaryDialog.hasApplication():
self.summaryDialog.show()
def setActionEnabled(self):
enabled = self.packageList.isSelected()
self.actionButton.setEnabled(enabled)
self.basket.setActionEnabled(enabled)
def switchState(self, state, action=True):
self.setSelectAll()
self.searchLine.clear()
self.state.setState(state)
self.setActionButton()
if action:
self.state.stateAction()
def emitStatusBarInfo(self, packages, packagesSize, extraPackages, extraPackagesSize):
self.emit(SIGNAL("selectionStatusChanged(QString)"), self.state.statusText(packages, packagesSize, extraPackages, extraPackagesSize))
def setSelectAll(self, packages=None):
if packages:
self.packageList.reverseSelection(packages)
self.selectAll.setText(i18n("Select all packages in this group"))
self.selectAll.setUrl("All")
def setReverseAll(self, packages=None):
if packages:
self.packageList.selectAll(packages)
self.selectAll.setText(i18n("Reverse package selections"))
self.selectAll.setUrl("Reverse")
def toggleSelectAll(self, text):
packages = self.packageList.model().getFilteredPackages()
if text == "All":
self.setReverseAll(packages)
else:
self.setSelectAll(packages)
self.statusChanged()
def showBasket(self):
waitCursor()
self.statusUpdater.wait()
self.basket.show()
restoreCursor()
class MainWidget(QtGui.QWidget, Ui_MainWidget):
def __init__(self, parent=None, silence = False):
QtGui.QWidget.__init__(self, parent)
self.setupUi(self)
self.parent = parent
self._selectedGroups = []
self.state = StateManager(self)
self.lastState = self.state.state
self.state.silence = silence
if not silence:
self.searchButton.setIcon(KIcon("edit-find"))
self.statusUpdater = StatusUpdater()
self.basket = BasketDialog(self.state)
self.searchUsed = False
self.initializeInfoBox()
self.initialize()
self.updateSettings()
self.actionButton.setIcon(self.state.getActionIcon())
self.connectMainSignals()
self.operation = OperationManager(self.state)
self.progressDialog = ProgressDialog(self.state)
self.summaryDialog = SummaryDialog()
self.connectOperationSignals()
def initializeInfoBox(self):
# An info label to show a proper information,
# if there is no updates available.
self.info = QtGui.QLabel(self)
self.info.setText(i18n("All Packages are up to date"))
self.info.setAlignment(Qt.AlignVCenter | Qt.AlignCenter)
self.info.setStyleSheet("background-color:rgba(0,0,0,220); \
color:white; \
border: 1px solid white; \
border-radius: 10px; \
")
self.info.resize(QSize(340, 80))
self.info.hide()
def resizeEvent(self, event):
# info label should be resized automatically,
# if the mainwindow resized.
self.info.move(self.width() / 2 - 170, self.height() / 2 - 40)
def connectMainSignals(self):
self.connect(self.actionButton, SIGNAL("clicked()"), self.showBasket)
self.connect(self.searchButton, SIGNAL("clicked()"), self.searchActivated)
self.connect(self.searchLine, SIGNAL("textEdited(const QString&)"), self.searchLineChanged)
self.connect(self.searchLine, SIGNAL("returnPressed()"), self.searchActivated)
self.connect(self.searchLine, SIGNAL("clearButtonClicked()"), self.groupFilter)
self.connect(self.typeCombo, SIGNAL("activated(int)"), self.typeFilter)
self.connect(self.groupList, SIGNAL("groupChanged()"), self.groupFilter)
self.connect(self.groupList, SIGNAL("groupChanged()"), lambda:self.searchButton.setEnabled(False))
self.connect(self.selectAll, SIGNAL("clicked(bool)"), self.toggleSelectAll)
self.connect(self.statusUpdater, SIGNAL("selectedInfoChanged(int, QString, int, QString)"), self.emitStatusBarInfo)
self.connect(self.statusUpdater, SIGNAL("selectedInfoChanged(QString)"), lambda message: self.emit(SIGNAL("selectionStatusChanged(QString)"), message))
self.connect(self.statusUpdater, SIGNAL("finished()"), self.statusUpdated)
def connectOperationSignals(self):
self.connect(self.operation, SIGNAL("exception(QString)"), self.exceptionCaught)
self.connect(self.operation, SIGNAL("finished(QString)"), self.actionFinished)
self.connect(self.operation, SIGNAL("started(QString)"), self.actionStarted)
self.connect(self.operation, SIGNAL("started(QString)"), self.progressDialog.updateActionLabel)
self.connect(self.operation, SIGNAL("operationCancelled()"), self.actionCancelled)
self.connect(self.operation, SIGNAL("progress(int)"), self.progressDialog.updateProgress)
self.connect(self.operation, SIGNAL("operationChanged(QString,QString)"), self.progressDialog.updateOperation)
self.connect(self.operation, SIGNAL("packageChanged(int, int, QString)"), self.progressDialog.updateStatus)
self.connect(self.operation, SIGNAL("elapsedTime(QString)"), self.progressDialog.updateRemainingTime)
self.connect(self.operation, SIGNAL("downloadInfoChanged(QString, QString, QString)"), self.progressDialog.updateCompletedInfo)
def initialize(self):
waitCursor()
self._last_packages = None
self.state.reset()
self.initializeUpdateTypeList()
self.initializePackageList()
self.initializeGroupList()
self.initializeStatusUpdater()
self.statusChanged()
self._selectedGroups = []
self.selectAll.setChecked(False)
restoreCursor()
QTimer.singleShot(1, self.initializeBasket)
def initializeUpdateTypeList(self):
self.typeCombo.clear()
UPDATE_TYPES = [['normal', i18n('All Updates'), 'system-software-update'],
['security', i18n('Security Updates'), 'security-medium'],
['critical', i18n('Critical Updates'), 'security-low']]
for type in UPDATE_TYPES:
self.typeCombo.addItem(KIcon(type[2], KIconLoader.SizeSmallMedium), type[1], QVariant(type[0]))
def initializeStatusUpdater(self):
self.statusUpdater.setModel(self.packageList.model().sourceModel())
def initializeBasket(self):
waitCursor()
self.basket.setModel(self.packageList.model().sourceModel())
restoreCursor()
def initializePackageList(self):
model = PackageModel(self)
proxy = PackageProxy(self)
proxy.setSourceModel(model)
self.packageList.setModel(proxy)
self.packageList.setItemDelegate(PackageDelegate(self))
self.packageList.setColumnWidth(0, 32)
self.packageList.setPackages(self.state.packages())
self.connect(self.packageList.model(), SIGNAL("dataChanged(QModelIndex,QModelIndex)"), self.statusChanged)
def updateSettings(self):
self.packageList.showComponents = config.PMConfig().showComponents()
self.packageList.setFocus()
def searchLineChanged(self, text):
self.searchButton.setEnabled(bool(text))
if text == '' and self.searchUsed:
self.searchActivated()
def statusUpdated(self):
if self.statusUpdater.needsUpdate:
self.statusUpdater.needsUpdate = False
self.statusChanged()
def statusChanged(self):
self.setActionEnabled()
if self.statusUpdater.isRunning():
self.statusUpdater.needsUpdate = True
else:
self.emit(SIGNAL("updatingStatus()"))
self.statusUpdater.start()
def initializeGroupList(self):
self.groupList.clear()
self.groupList.setAlternatingRowColors(True)
self.groupList.setIconSize(QSize(KIconLoader.SizeLarge, KIconLoader.SizeLarge))
self.groupList.setState(self.state)
self.groupList.addGroups(self.state.groups())
if self.state.state == self.state.UPGRADE:
self.typeCombo.show()
else:
self.typeCombo.hide()
self.state._typeFilter = 'normal'
self.groupFilter()
# Show the info label if there are updates available
# otherwise hide it.
if self.state.inUpgrade() and self.groupList.count() == 0:
self.info.show()
else:
self.info.hide()
def packageFilter(self, text):
self.packageList.model().setFilterRole(Qt.DisplayRole)
self.packageList.model().setFilterRegExp(QRegExp(unicode(text), Qt.CaseInsensitive, QRegExp.FixedString))
def typeFilter(self, index):
if self.state.state == self.state.UPGRADE:
filter = self.typeCombo.itemData(index).toString()
if not self.state._typeFilter == filter:
self.state._typeFilter = filter
self.initializeGroupList()
def groupFilter(self):
self.packageList.resetMoreInfoRow()
packages = self.state.groupPackages(self.groupList.currentGroup())
self.packageList.model().setFilterRole(GroupRole)
waitCursor()
self.packageList.model().setFilterPackages(packages)
self.packageList.scrollToTop()
self.selectAll.setChecked(self.groupList.currentGroup() in self._selectedGroups)
restoreCursor()
def searchActivated(self):
self.packageList.resetMoreInfoRow()
waitCursor()
searchText = str(self.searchLine.text()).split()
if searchText:
sourceModel = self.packageList.model().sourceModel()
self.state.cached_packages = sourceModel.search(searchText)
self.groupList.lastSelected = None
self.searchUsed = True
else:
self.state.cached_packages = None
self.state.packages()
self.searchUsed = False
self.initializeGroupList()
restoreCursor()
def setActionButton(self):
self.actionButton.setEnabled(False)
self.actionButton.setText(self.state.getActionName())
self.actionButton.setIcon(self.state.getActionIcon())
def actionStarted(self, operation):
if self.state.silence:
totalPackages = len(self.state._selected_packages)
if not any(package.endswith('.pisi') for package in self.state._selected_packages):
totalPackages += len(self.state.iface.getExtras(self.state._selected_packages))
self.progressDialog.reset()
if not operation in ["System.Manager.updateRepository", "System.Manager.updateAllRepositories"]:
if not self.state.silence:
totalPackages = self.packageList.packageCount()
self.operation.setTotalPackages(totalPackages)
self.progressDialog.updateStatus(0, totalPackages, self.state.toBe())
if self.isVisible():
if operation in ["System.Manager.updateRepository", "System.Manager.updateAllRepositories"]:
self.progressDialog.repoOperationView()
self.progressDialog.show()
self.progressDialog.enableCancel()
def exceptionCaught(self, message):
self.progressDialog.hide()
if any(warning in message for warning in ('urlopen error','Socket Error', 'PYCURL ERROR')):
errorTitle = i18n("Network Error")
errorMessage = i18n("Please check your network connections and try again.")
elif "Access denied" in message or "tr.org.pardus.comar.Comar.PolicyKit" in message:
errorTitle = i18n("Authorization Error")
errorMessage = i18n("You are not authorized for this operation.")
elif "HTTP Error 404" in message:
errorTitle = i18n("Pisi Error")
errorMessage = i18n("Package not found. It may be upgraded in or removed from the repository. Please try upgrading repository informations.")
else:
errorTitle = i18n("Pisi Error")
errorMessage = message
self.messageBox = QtGui.QMessageBox(errorTitle, errorMessage, QtGui.QMessageBox.Critical, QtGui.QMessageBox.Ok, 0, 0)
self.messageBox.show()
if self.state.state == self.state.UPGRADE:
{self.state.INSTALL:self.parent.showInstallAction,
self.state.REMOVE :self.parent.showRemoveAction}[self.lastState].setChecked(True)
self.switchState(self.lastState)
def actionFinished(self, operation):
if operation == "System.Manager.installPackage":
self.showSummary()
if operation in ("System.Manager.installPackage", "System.Manager.removePackage", "System.Manager.updatePackage"):
self.notifyFinished()
if not self.state.silence:
self.searchLine.clear()
self.state.reset()
self.progressDialog.hide()
if operation in ("System.Manager.updateRepository", "System.Manager.updateAllRepositories"):
self.emit(SIGNAL("repositoriesUpdated()"))
self.initialize()
else:
QtGui.qApp.exit()
def actionCancelled(self):
self.progressDialog.hide()
if self.state.silence:
QtGui.qApp.exit()
else:
self.groupFilter()
def notifyFinished(self):
if not self.operation.totalPackages:
return
if self.state.silence:
Pds.notify(i18n('Package Manager'), self.state.getSummaryInfo(self.operation.totalPackages))
elif Pds.session == pds.Kde4:
from PyKDE4.kdeui import KNotification
from PyKDE4.kdecore import KComponentData
KNotification.event("Summary",
self.state.getSummaryInfo(self.operation.totalPackages),
QtGui.QPixmap(),
None,
KNotification.CloseOnTimeout,
KComponentData("package-manager", "package-manager", KComponentData.SkipMainComponentRegistration)
)
else:
Pds.notify(i18n('Package Manager'), self.state.getSummaryInfo(self.operation.totalPackages))
def showSummary(self):
self.summaryDialog.setDesktopFiles(self.operation.desktopFiles)
if self.summaryDialog.hasApplication():
self.summaryDialog.show()
def setActionEnabled(self):
enabled = self.packageList.isSelected()
self.actionButton.setEnabled(enabled)
self.basket.setActionEnabled(enabled)
def switchState(self, state, action=True):
self.searchLine.clear()
self.lastState = self.state.state
self.state.setState(state)
self._selectedGroups = []
self.setActionButton()
if action:
self.state.stateAction()
self.initialize()
def emitStatusBarInfo(self, packages, packagesSize, extraPackages, extraPackagesSize):
self.emit(SIGNAL("selectionStatusChanged(QString)"), self.state.statusText(packages, packagesSize, extraPackages, extraPackagesSize))
def setSelectAll(self, packages=None):
if packages:
self.packageList.reverseSelection(packages)
def setReverseAll(self, packages=None):
if packages:
self.packageList.selectAll(packages)
def toggleSelectAll(self, toggled):
self._last_packages = self.packageList.model().getFilteredPackages()
if toggled:
if self.groupList.currentGroup() not in self._selectedGroups:
self._selectedGroups.append(self.groupList.currentGroup())
self.setReverseAll(self._last_packages)
else:
if self.groupList.currentGroup() in self._selectedGroups:
self._selectedGroups.remove(self.groupList.currentGroup())
self.setSelectAll(self._last_packages)
# A hacky solution to repaint the list to take care of selection changes
# FIXME Later
self.packageList.setFocus()
self.statusChanged()
def showBasket(self):
waitCursor()
self.statusUpdater.wait()
self.basket.show()
restoreCursor()
class MainWidget(QWidget, PM, Ui_MainWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setupUi(self)
self.parent = parent
self._selectedGroups = []
self._preexceptions = []
self._postexceptions = []
self.state = StateManager(self)
self.currentState = None
self.completer = None
self._updatesCheckedOnce = False
# Search Thread
self._searchThread = PThread(self, self.startSearch,
self.searchFinished)
self.statusUpdater = StatusUpdater()
self.basket = BasketDialog(self.state, self.parent)
self._postexceptions.append(lambda: self.basket.setActionEnabled(True))
self.searchButton.setIcon(KIcon(("edit-find", "find")))
self.initializeUpdateTypeList()
model = PackageModel(self)
proxy = PackageProxy(self)
proxy.setSourceModel(model)
self.packageList.setModel(proxy)
self.packageList.setItemDelegate(PackageDelegate(self, self.parent))
self.packageList.setColumnWidth(0, 32)
self.packageList.model().dataChanged.connect(self.statusChanged)
self.packageList.updateRequested.connect(self.initialize)
self.updateSettings()
self.setActionButton()
self.operation = OperationManager(self.state)
self.progressDialog = ProgressDialog(self.state, self.parent)
self._preexceptions.append(self.progressDialog._hide)
self.progressDialog.registerFunction(
FINISHED, lambda: self.parent.statusBar().setVisible(
not self.progressDialog.isVisible()))
self.progressDialog.registerFunction(
OUT, lambda: self.parent.statusBar().show())
self.summaryDialog = SummaryDialog()
self.connectOperationSignals()
self.pdsMessageBox = PMessageBox(self.content)
def connectMainSignals(self):
self.actionButton.clicked.connect(self.showBasket)
self.checkUpdatesButton.clicked.connect(self.state.updateRepoAction)
self.searchButton.clicked.connect(self.searchActivated)
self.searchLine.textEdited.connect(self.searchLineChanged)
self.searchLine.returnPressed.connect(self.searchActivated)
self.searchLine.clearButtonClicked.connect(self.groupFilter)
self.typeCombo.activated.connect(self.typeFilter)
self.stateTab.currentChanged.connect(self.switchState)
self.groupList.groupChanged.connect(self.groupFilter)
self.groupList.groupChanged.connect(
lambda: self.searchButton.setEnabled(False))
self.packageList.select_all.clicked.connect(self.toggleSelectAll)
self.statusUpdater.selectedInfoChanged.connect(self.emitStatusBarInfo)
self.statusUpdater.selectedInfoChanged.connect(
lambda message: self.selectionStatusChanged.emit(message))
self.statusUpdater.finished.connect(self.statusUpdated)
def initialize(self):
waitCursor()
self.searchLine.clear()
self._started = False
self._last_packages = None
self.state.reset()
self.initializePackageList()
self.initializeGroupList()
self.initializeStatusUpdater()
self.statusChanged()
self._selectedGroups = []
self.packageList.select_all.setChecked(False)
self.initializeBasket()
self.searchLine.setFocus(True)
if self.currentState == self.state.UPGRADE:
if self.groupList.count() == 0:
QTimer.singleShot(0, \
lambda: self.pdsMessageBox.showMessage(self.tr("All packages are up to date"), icon = "info"))
if self.groupList.count() > 0:
if self.state.inUpgrade():
self.pdsMessageBox.hideMessage(force=True)
restoreCursor()
def initializeStatusUpdater(self):
self.statusUpdater.calculate_deps = not self.state.state == self.state.ALL
self.statusUpdater.setModel(self.packageList.model().sourceModel())
def initializeBasket(self):
waitCursor()
self.basket.setModel(self.packageList.model().sourceModel())
restoreCursor()
def initializePackageList(self):
self.packageList.model().reset()
self.packageList.setPackages(self.state.packages())
if self.completer:
self.completer.deleteLater()
del self.completer
self.completer = QCompleter(self.state.packages(), self)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.searchLine.setCompleter(self.completer)
def selectComponent(self, component):
if not self.state.iface.operationInProgress():
if self.basket.isVisible():
self.basket._hide()
self.stateTab.setCurrentIndex(1)
self.switchState(self.state.INSTALL)
if component in self.groupList._list:
self.groupList.setCurrentItem(self.groupList._list[component])
self.groupFilter()
def updateSettings(self):
self.packageList.showComponents = PMConfig().showComponents()
self.packageList.showIsA = PMConfig().showIsA()
self.packageList.setFocus()
def searchLineChanged(self, text):
self.searchButton.setEnabled(bool(text))
if text == '':
self.searchActivated()
def statusUpdated(self):
if self.statusUpdater.needsUpdate:
self.statusUpdater.needsUpdate = False
self.statusChanged()
updatingStatus = pyqtSignal()
def statusChanged(self):
self.setActionEnabled()
if self.statusUpdater.isRunning():
self.statusUpdater.needsUpdate = True
else:
self.updatingStatus.emit()
self.statusUpdater.start()
def initializeGroupList(self):
self.groupList.clear()
self.groupList._list = {}
self.groupList.setAlternatingRowColors(True)
self.groupList.setIconSize(QSize(32, 32))
self.groupList.setState(self.state)
self.groupList.addGroups(self.state.groups())
if self.state.state == self.state.UPGRADE:
self.typeCombo.show()
else:
self.typeCombo.hide()
self.state._typeFilter = 'normal'
self.groupFilter()
def packageFilter(self, text):
self.packageList.model().setFilterRole(Qt.DisplayRole)
self.packageList.model().setFilterRegExp(
QRegExp(unicode(text), Qt.CaseInsensitive, QRegExp.FixedString))
def typeFilter(self, index):
if self.state.state == self.state.UPGRADE:
filter = self.typeCombo.itemData(index).toString()
if not self.state._typeFilter == filter:
self.state._typeFilter = filter
self.initializeGroupList()
def groupFilter(self):
waitCursor()
self.packageList.resetMoreInfoRow()
packages = self.state.groupPackages(self.groupList.currentGroup())
self.packageList.model().setFilterRole(GroupRole)
self.packageList.model().setFilterPackages(packages)
self.packageList.scrollToTop()
self.packageList.select_all.setChecked(
self.groupList.currentGroup() in self._selectedGroups)
restoreCursor()
def searchActivated(self):
if self.currentState == self.state.UPGRADE:
if self.groupList.count() == 0 and not self.searchUsed:
return
if not self.searchLine.text() == '':
self.pdsMessageBox.showMessage(self.tr("Searching..."), busy=True)
self.groupList.lastSelected = None
self._searchThread.start()
self.searchUsed = True
else:
self.state.cached_packages = None
self.state.packages()
self.searchUsed = False
self.searchFinished()
def searchFinished(self):
if self.state.cached_packages == []:
self.pdsMessageBox.showMessage(self.tr("No results found."),
"dialog-information")
else:
self.pdsMessageBox.hideMessage()
self.initializeGroupList()
def startSearch(self):
searchText = str(self.searchLine.text()).split()
sourceModel = self.packageList.model().sourceModel()
self.state.cached_packages = sourceModel.search(searchText)
def setActionButton(self):
self.actionButton.setEnabled(False)
if self.state.state == self.state.ALL:
menu = QMenu(self.actionButton)
self.__install_action = menu.addAction(
self.state.getActionIcon(self.state.INSTALL),
self.state.getActionName(self.state.INSTALL), self.showBasket)
self.__remove_action = menu.addAction(
self.state.getActionIcon(self.state.REMOVE),
self.state.getActionName(self.state.REMOVE), self.showBasket)
self.actionButton.setMenu(menu)
else:
self.actionButton.setMenu(None)
self.actionButton.setIcon(self.state.getActionIcon())
self.actionButton.setText(self.state.getActionName())
def actionStarted(self, operation):
self.pdsMessageBox.hideMessage()
self.progressDialog.reset()
if not operation in [
"System.Manager.updateRepository",
"System.Manager.updateAllRepositories"
]:
totalPackages = self.packageList.packageCount()
self.operation.setTotalPackages(totalPackages)
self.progressDialog.updateStatus(0, totalPackages,
self.state.toBe())
if self.isVisible():
if operation in [
"System.Manager.updateRepository",
"System.Manager.updateAllRepositories"
]:
self.progressDialog.repoOperationView()
if self.basket.isVisible():
self.basket._hide()
QTimer.singleShot(0, self.progressDialog._show)
else:
self.progressDialog._show()
if not self._started:
self.progressDialog.disableCancel()
else:
self.progressDialog.enableCancel()
repositoriesUpdated = pyqtSignal()
def actionFinished(self, operation):
if operation in ("System.Manager.installPackage",
"System.Manager.removePackage",
"System.Manager.updatePackage"):
self.notifyFinished()
if operation == "System.Manager.installPackage" and self._started:
KIconLoader.updateAvailableIcons()
self.summaryDialog.setDesktopFiles(self.operation.desktopFiles)
self.summaryDialog.showSummary()
if operation in ("System.Manager.updateRepository",
"System.Manager.updateAllRepositories"):
self.repositoriesUpdated.emit()
self.searchLine.clear()
self.state.reset()
self.progressDialog._hide()
if not self.currentState == self.state.UPGRADE:
self.switchState(self.currentState)
self.initialize()
def actionCancelled(self):
self.progressDialog._hide()
self.progressDialog.reset()
self.switchState(self.currentState)
self.groupFilter()
def setActionEnabled(self):
enabled = self.packageList.isSelected()
self.actionButton.setEnabled(enabled)
self.basket.setActionEnabled(enabled)
def switchState(self, state):
self.pdsMessageBox.hideMessage()
self._states[state][1].setChecked(True)
self.state.setState(state)
self.currentState = state
self._selectedGroups = []
if not state == self.state.HISTORY:
self.setActionButton()
self.state.cached_packages = None
if state == self.state.UPGRADE or (state == self.state.INSTALL and
self.groupList.count() == 1):
if not self._updatesCheckedOnce:
self._updatesCheckedOnce = self.state.updateRepoAction(
silence=True)
self.checkUpdatesButton.setHidden(not state == self.state.UPGRADE)
self.initialize()
def emitStatusBarInfo(self, packages, packagesSize, extraPackages,
extraPackagesSize):
self.selectionStatusChanged.emit(
self.state.statusText(packages, packagesSize, extraPackages,
extraPackagesSize))
def setSelectAll(self, packages=None):
if packages:
self.packageList.reverseSelection(packages)
def setReverseAll(self, packages=None):
if packages:
self.packageList.selectAll(packages)
def toggleSelectAll(self, toggled):
self._last_packages = self.packageList.model().getFilteredPackages()
if toggled:
if self.groupList.currentGroup() not in self._selectedGroups:
self._selectedGroups.append(self.groupList.currentGroup())
self.setReverseAll(self._last_packages)
else:
if self.groupList.currentGroup() in self._selectedGroups:
self._selectedGroups.remove(self.groupList.currentGroup())
self.setSelectAll(self._last_packages)
self.packageList.setFocus()
self.statusChanged()
def showBasket(self):
if self.basket.isVisible():
return
waitCursor()
self.statusUpdater.wait()
if self.currentState == self.state.ALL:
action = {
self.__remove_action: self.state.REMOVE,
self.__install_action: self.state.INSTALL
}.get(self.sender(), self.state.INSTALL)
if action:
if action == self.state.REMOVE:
installed_packages = self.state.iface.getInstalledPackages(
)
filtered_packages = filter(
lambda x: x not in installed_packages,
self.basket.model.selectedPackages())
if filtered_packages == self.basket.model.selectedPackages(
):
restoreCursor()
QMessageBox(
self.tr("Select packages"),
self.
tr("You must select at least one installed package"
), QMessageBox.Information, QMessageBox.Ok, 0,
0).exec_()
return
self.packageList.model().sourceModel().selectPackages(
filtered_packages, state=False)
self.state.state = action
self.basket._show()
restoreCursor()
def initializeUpdateTypeList(self):
self.typeCombo.clear()
UPDATE_TYPES = [[
'normal',
self.tr('All Updates'), ('system-software-update', 'ledgreen')
],
[
'security',
self.tr('Security Updates'),
('security-medium', 'ledyellow')
],
[
'critical',
self.tr('Critical Updates'),
('security-low', 'ledred')
]]
for type in UPDATE_TYPES:
self.typeCombo.addItem(KIcon(type[2]), type[1], QVariant(type[0]))
class MainWidget(QWidget, PM, Ui_MainWidget):
def __init__(self, parent = None):
QWidget.__init__(self, parent)
self.setupUi(self)
self.parent = parent
self._selectedGroups = []
self._preexceptions = []
self._postexceptions = []
self.state = StateManager(self)
self.currentState = None
self.completer = None
self._updatesCheckedOnce = False
#set style
self._style = "/usr/share/kde4/apps/package-manager/data/style.qss"
self.setStyleSheet(file(self._style).read())
# Search Thread
self._searchThread = PThread(self, self.startSearch, self.searchFinished)
self.statusUpdater = StatusUpdater()
self.basket = BasketDialog(self.state, self.parent)
self._postexceptions.append(lambda: self.basket.setActionEnabled(True))
self.searchButton.setIcon(KIcon("edit-find"))
self.initializeUpdateTypeList()
self.morewidgets = MoreWidgets(self.state, self.parent)
self.morewidgets._show()
self.webdialog = WebDialog(self.state, self.parent)
model = PackageModel(self)
proxy = PackageProxy(self)
proxy.setSourceModel(model)
self.packageList.setModel(proxy)
self.packageList.setItemDelegate(PackageDelegate(self, self.parent))
self.packageList.setColumnWidth(0, 32)
self.connect(self.packageList.model(), SIGNAL("dataChanged(QModelIndex,QModelIndex)"), self.statusChanged)
self.connect(self.packageList, SIGNAL("updateRequested()"), self.initialize)
self.connect(self.morewidgets.randomPackageList, SIGNAL("itemDoubleClicked(QListWidgetItem*)"), self.showWebdialog)
self.updateSettings()
self.setActionButton()
self.operation = OperationManager(self.state)
self.progressDialog = ProgressDialog(self.state, self.parent)
self._preexceptions.append(self.progressDialog._hide)
self.progressDialog.registerFunction(FINISHED, lambda: self.parent.statusBar().setVisible(not self.progressDialog.isVisible()))
self.progressDialog.registerFunction(OUT, lambda: self.parent.statusBar().show())
self.summaryDialog = SummaryDialog()
self.connectOperationSignals()
self.pdsMessageBox = PMessageBox(self.content)
def connectMainSignals(self):
self.connect(self.actionButton, SIGNAL("clicked()"), self.showBasket)
self.connect(self.buttonMore, SIGNAL("clicked()"), self.showMoreWidgets)
self.connect(self.checkUpdatesButton, SIGNAL("clicked()"), self.state.updateRepoAction)
self.connect(self.searchButton, SIGNAL("clicked()"), self.searchActivated)
self.connect(self.searchLine, SIGNAL("textEdited(const QString&)"), self.searchLineChanged)
self.connect(self.searchLine, SIGNAL("returnPressed()"), self.searchActivated)
self.connect(self.searchLine, SIGNAL("clearButtonClicked()"), self.groupFilter)
self.connect(self.typeCombo, SIGNAL("activated(int)"), self.typeFilter)
self.connect(self.stateTab, SIGNAL("currentChanged(int)"), self.switchState)
self.connect(self.groupList, SIGNAL("groupChanged()"), self.groupFilter)
self.connect(self.groupList, SIGNAL("groupChanged()"), lambda:self.searchButton.setEnabled(False))
self.connect(self.packageList.select_all, SIGNAL("clicked(bool)"), self.toggleSelectAll)
self.connect(self.statusUpdater, SIGNAL("selectedInfoChanged(int, QString, int, QString)"), self.emitStatusBarInfo)
self.connect(self.statusUpdater, SIGNAL("selectedInfoChanged(QString)"), lambda message: self.emit(SIGNAL("selectionStatusChanged(QString)"), message))
self.connect(self.statusUpdater, SIGNAL("finished()"), self.statusUpdated)
def initialize(self):
waitCursor()
self.searchLine.clear()
self._started = False
self._last_packages = None
self.state.reset()
self.initializePackageList()
self.initializeGroupList()
self.initializeStatusUpdater()
self.statusChanged()
self._selectedGroups = []
self.packageList.select_all.setChecked(False)
self.initializeBasket()
self.searchLine.setFocus(True)
if self.currentState == self.state.UPGRADE:
if self.groupList.count() == 0:
QTimer.singleShot(0, \
lambda: self.pdsMessageBox.showMessage(i18n("All packages are up to date"), icon = "games-endturn"))
if self.groupList.count() > 0:
if self.state.inUpgrade():
self.pdsMessageBox.hideMessage(force = True)
restoreCursor()
def initializeStatusUpdater(self):
self.statusUpdater.calculate_deps = not self.state.state == self.state.ALL
self.statusUpdater.setModel(self.packageList.model().sourceModel())
def initializeBasket(self):
waitCursor()
self.basket.setModel(self.packageList.model().sourceModel())
restoreCursor()
def initializePackageList(self):
self.packageList.model().reset()
self.packageList.setPackages(self.state.packages())
if self.completer:
self.completer.deleteLater()
del self.completer
self.completer = QCompleter(self.state.packages(), self)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.searchLine.setCompleter(self.completer)
def selectComponent(self, component):
if not self.state.iface.operationInProgress():
if self.basket.isVisible():
self.basket._hide()
self.stateTab.setCurrentIndex(1)
self.switchState(self.state.INSTALL)
if component in self.groupList._list:
self.groupList.setCurrentItem(self.groupList._list[component])
self.groupFilter()
def updateSettings(self):
self.packageList.showComponents = PMConfig().showComponents()
self.packageList.showIsA = PMConfig().showIsA()
self.packageList.setFocus()
def searchLineChanged(self, text):
self.searchButton.setEnabled(bool(text))
if text == '':
self.searchActivated()
def statusUpdated(self):
if self.statusUpdater.needsUpdate:
self.statusUpdater.needsUpdate = False
self.statusChanged()
def statusChanged(self):
self.setActionEnabled()
if self.statusUpdater.isRunning():
self.statusUpdater.needsUpdate = True
else:
self.emit(SIGNAL("updatingStatus()"))
self.statusUpdater.start()
def initializeGroupList(self):
self.groupList.clear()
self.groupList._list = {}
self.groupList.setAlternatingRowColors(False)
self.groupList.setIconSize(QSize(32, 32))
self.groupList.setState(self.state)
self.groupList.addGroups(self.state.groups())
if self.state.state == self.state.UPGRADE:
self.typeCombo.show()
else:
self.typeCombo.hide()
self.state._typeFilter = 'normal'
self.groupFilter()
def packageFilter(self, text):
self.packageList.model().setFilterRole(Qt.DisplayRole)
self.packageList.model().setFilterRegExp(QRegExp(unicode(text), Qt.CaseInsensitive, QRegExp.FixedString))
def typeFilter(self, index):
if self.state.state == self.state.UPGRADE:
filter = self.typeCombo.itemData(index).toString()
if not self.state._typeFilter == filter:
self.state._typeFilter = filter
self.initializeGroupList()
def groupFilter(self):
waitCursor()
self.packageList.resetMoreInfoRow()
packages = self.state.groupPackages(self.groupList.currentGroup())
self.packageList.model().setFilterRole(GroupRole)
self.packageList.model().setFilterPackages(packages)
self.packageList.scrollToTop()
self.packageList.select_all.setChecked(self.groupList.currentGroup() in self._selectedGroups)
restoreCursor()
def searchActivated(self):
if self.currentState == self.state.UPGRADE:
if self.groupList.count() == 0 and not self.searchUsed:
return
if not self.searchLine.text() == '':
self.pdsMessageBox.showMessage(i18n("Searching..."), busy = True)
self.groupList.lastSelected = None
self._searchThread.start()
self.searchUsed = True
else:
self.state.cached_packages = None
self.state.packages()
self.searchUsed = False
self.searchFinished()
def searchFinished(self):
if self.state.cached_packages == []:
self.pdsMessageBox.showMessage(i18n("No results found."), "dialog-information")
else:
self.pdsMessageBox.hideMessage()
self.initializeGroupList()
def startSearch(self):
searchText = str(self.searchLine.text()).split()
sourceModel = self.packageList.model().sourceModel()
self.state.cached_packages = sourceModel.search(searchText)
def setActionButton(self):
self.actionButton.setEnabled(False)
if self.state.state == self.state.ALL:
menu = QMenu(self.actionButton)
self.__install_action = menu.addAction(self.state.getActionIcon(self.state.INSTALL),
self.state.getActionName(self.state.INSTALL),
self.showBasket)
self.__remove_action = menu.addAction(self.state.getActionIcon(self.state.REMOVE),
self.state.getActionName(self.state.REMOVE),
self.showBasket)
self.actionButton.setMenu(menu)
else:
self.actionButton.setMenu(None)
self.actionButton.setIcon(self.state.getActionIcon())
self.actionButton.setText(self.state.getActionName())
def actionStarted(self, operation):
self.pdsMessageBox.hideMessage()
self.progressDialog.reset()
if not operation in ["System.Manager.updateRepository", "System.Manager.updateAllRepositories"]:
totalPackages = self.packageList.packageCount()
extraPackages = self.packageList.extraPackagesCount()
self.operation.setTotalPackages(totalPackages)
self.operation.setExtraPackages(extraPackages)
self.progressDialog.updateStatus(0, totalPackages, self.state.toBe())
if self.isVisible():
if operation in ["System.Manager.updateRepository", "System.Manager.updateAllRepositories"]:
self.progressDialog.repoOperationView()
if self.basket.isVisible():
self.basket._hide()
QTimer.singleShot(0, self.progressDialog._show)
else:
self.progressDialog._show()
if not self._started:
self.progressDialog.disableCancel()
else:
self.progressDialog.enableCancel()
def actionFinished(self, operation):
if operation in ("System.Manager.installPackage",
"System.Manager.removePackage",
"System.Manager.updatePackage"):
self.notifyFinished()
if operation == "System.Manager.installPackage" and self._started:
self.summaryDialog.setDesktopFiles(self.operation.desktopFiles)
self.summaryDialog.showSummary()
if operation in ("System.Manager.updateRepository",
"System.Manager.updateAllRepositories"):
self.emit(SIGNAL("repositoriesUpdated()"))
self.searchLine.clear()
self.state.reset()
self.progressDialog._hide()
if not self.currentState == self.state.UPGRADE:
self.switchState(self.currentState)
self.initialize()
def actionCancelled(self):
self.progressDialog._hide()
self.progressDialog.reset()
self.switchState(self.currentState)
self.groupFilter()
def setActionEnabled(self):
enabled = self.packageList.isSelected()
self.actionButton.setEnabled(enabled)
self.basket.setActionEnabled(enabled)
def switchState(self, state):
self.pdsMessageBox.hideMessage(force = True)
self._states[state][1].setChecked(True)
self.state.setState(state)
self.currentState = state
self._selectedGroups = []
if not state == self.state.HISTORY:
self.setActionButton()
self.state.cached_packages = None
if state == self.state.UPGRADE or (state == self.state.INSTALL and self.groupList.count() == 1):
if not self._updatesCheckedOnce:
self._updatesCheckedOnce = self.state.updateRepoAction(silence = True)
self.checkUpdatesButton.setHidden(not state == self.state.UPGRADE)
self.initialize()
# self.contentHistory.hide()
self.content.show()
# else:
# self.contentHistory.show()
# self.content.hide()
def emitStatusBarInfo(self, packages, packagesSize, extraPackages, extraPackagesSize):
self.emit(SIGNAL("selectionStatusChanged(QString)"), self.state.statusText(packages, packagesSize, extraPackages, extraPackagesSize))
def setSelectAll(self, packages=None):
if packages:
self.packageList.reverseSelection(packages)
def setReverseAll(self, packages=None):
if packages:
self.packageList.selectAll(packages)
def toggleSelectAll(self, toggled):
self._last_packages = self.packageList.model().getFilteredPackages()
if toggled:
if self.groupList.currentGroup() not in self._selectedGroups:
self._selectedGroups.append(self.groupList.currentGroup())
self.setReverseAll(self._last_packages)
else:
if self.groupList.currentGroup() in self._selectedGroups:
self._selectedGroups.remove(self.groupList.currentGroup())
self.setSelectAll(self._last_packages)
# A hacky solution to repaint the list to take care of selection changes
# FIXME Later
self.packageList.setFocus()
self.statusChanged()
def showBasket(self):
if self.basket.isVisible():
return
waitCursor()
self.statusUpdater.wait()
if self.currentState == self.state.ALL:
action = {self.__remove_action:self.state.REMOVE,
self.__install_action:self.state.INSTALL}.get(self.sender(), self.state.INSTALL)
if action:
if action == self.state.REMOVE:
installed_packages = self.state.iface.getInstalledPackages()
filtered_packages = filter(lambda x: x not in installed_packages, self.basket.model.selectedPackages())
if filtered_packages == self.basket.model.selectedPackages():
restoreCursor()
QMessageBox(i18n("Select packages"),
i18n("You must select at least one installed package"),
QMessageBox.Information, QMessageBox.Ok, 0, 0).exec_()
return
self.packageList.model().sourceModel().selectPackages(filtered_packages, state = False)
self.state.state = action
self.basket._show()
restoreCursor()
def showMoreWidgets(self):
if self.morewidgets.isVisible():
return
waitCursor()
self.morewidgets._show()
restoreCursor()
def showWebdialog(self):
packageName = str(unicode(self.morewidgets.randomPackageList.currentItem().text()))
liste = []
liste.append(packageName)
print liste
waitCursor()
self.morewidgets._hide()
#self.webdialog._show()
restoreCursor()
#self.packageList.setPackages(liste)
self.packageList.selectAll(liste)
#self.packageList.setItemDelegate(PackageDelegate(self, self, showDetailsButton=True))
#self.packageList.setColumnWidth(0, 32)
self.operation = OperationManager(self.state)
reinstall = False
answer = True
actions = self.state.checkInstallActions(liste)
if actions:
answer = askForActions(actions,
i18n("Selected packages are already installed.<br>"
"If you continue, the packages will be reinstalled"),
i18n("Already Installed Packages"),
i18n("Installed Packages"))
if not answer:
self.initializePackageList()
self.initializeBasket()
self.initializeStatusUpdater()
self.state.state = self.parent.cw.currentState
self.parent.cw.initialize()
return
if actions:
reinstall = True
if reinstall == False:
self.initializeStatusUpdater()
self.initializeBasket()
self.statusUpdated()
self.showBasket()
self.initializeBasket()
self.initializeStatusUpdater()
def initializeUpdateTypeList(self):
self.typeCombo.clear()
UPDATE_TYPES = [['normal', i18n('All Updates'), 'system-software-update'],
['security', i18n('Security Updates'), 'security-medium'],
['critical', i18n('Critical Updates'), 'security-low']]
for type in UPDATE_TYPES:
self.typeCombo.addItem(KIcon(type[2]), type[1], QVariant(type[0]))
class MainWidget(QtGui.QWidget, Ui_MainWidget):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.setupUi(self)
self.searchButton.setIcon(KIcon("edit-find"))
self.statusUpdater = StatusUpdater()
self.state = StateManager(self)
self.session = SessionManager()
self.basket = BasketDialog(self.state)
self.initialize()
self.setSelectAll()
self.actionButton.setIcon(self.state.getActionIcon())
self.operation = OperationManager(self.state)
self.progressDialog = ProgressDialog(self.state)
self.summaryDialog = SummaryDialog()
self.connectMainSignals()
self.connectOperationSignals()
def connectMainSignals(self):
self.connect(self.actionButton, SIGNAL("clicked()"), self.showBasket)
self.connect(self.searchButton, SIGNAL("clicked()"),
self.searchActivated)
self.connect(self.searchLine, SIGNAL("textEdited(const QString&)"),
self.searchLineChanged)
self.connect(self.searchLine, SIGNAL("returnPressed()"),
self.searchActivated)
self.connect(self.searchLine, SIGNAL("clearButtonClicked()"),
self.groupFilter)
self.connect(self.groupList, SIGNAL("groupChanged()"),
self.groupFilter)
self.connect(self.groupList, SIGNAL("groupChanged()"),
self.searchLine.clear)
self.connect(self.groupList, SIGNAL("groupChanged()"),
lambda: self.searchButton.setEnabled(False))
self.connect(self.selectAll, SIGNAL("leftClickedUrl(const QString&)"),
self.toggleSelectAll)
self.connect(self.statusUpdater,
SIGNAL("selectedInfoChanged(int, QString, int, QString)"),
self.emitStatusBarInfo)
self.connect(self.statusUpdater, SIGNAL("finished()"),
self.statusUpdated)
def connectOperationSignals(self):
self.connect(self.operation, SIGNAL("exception(QString)"),
self.exceptionCaught)
self.connect(self.operation, SIGNAL("finished(QString)"),
self.actionFinished)
self.connect(self.operation, SIGNAL("started(QString)"),
self.actionStarted)
self.connect(self.operation, SIGNAL("started(QString)"),
self.progressDialog.updateActionLabel)
self.connect(self.operation, SIGNAL("operationCancelled()"),
self.progressDialog.hide)
self.connect(self.operation, SIGNAL("progress(int)"),
self.progressDialog.updateProgress)
self.connect(self.operation,
SIGNAL("operationChanged(QString,QString)"),
self.progressDialog.updateOperation)
self.connect(self.operation,
SIGNAL("packageChanged(int, int, QString)"),
self.progressDialog.updateStatus)
self.connect(self.operation, SIGNAL("elapsedTime(QString)"),
self.progressDialog.updateRemainingTime)
self.connect(self.operation,
SIGNAL("downloadInfoChanged(QString, QString, QString)"),
self.progressDialog.updateCompletedInfo)
def initialize(self):
waitCursor()
self.state.reset()
self.initializePackageList()
self.initializeGroupList()
self.initializeBasket()
self.initializeStatusUpdater()
self.statusChanged()
restoreCursor()
def initializeStatusUpdater(self):
self.statusUpdater.setModel(self.packageList.model().sourceModel())
def initializeBasket(self):
self.basket.setModel(self.packageList.model().sourceModel())
def initializePackageList(self):
self.packageList.setModel(PackageProxy(self))
self.packageList.model().setSourceModel(PackageModel(self))
self.packageList.setItemDelegate(PackageDelegate(self))
self.packageList.setColumnWidth(0, 32)
self.packageList.setAlternatingRowColors(True)
self.packageList.setSelectionMode(
QtGui.QAbstractItemView.MultiSelection)
self.packageList.setPackages(self.state.packages())
self.connect(self.packageList.model(),
SIGNAL("dataChanged(QModelIndex,QModelIndex)"),
self.statusChanged)
def searchLineChanged(self, text):
self.searchButton.setEnabled(bool(text))
def statusUpdated(self):
if self.statusUpdater.needsUpdate:
self.statusUpdater.needsUpdate = False
self.statusChanged()
def statusChanged(self):
self.setActionEnabled()
if self.statusUpdater.isRunning():
self.statusUpdater.needsUpdate = True
else:
self.emit(SIGNAL("updatingStatus()"))
self.statusUpdater.start()
def initializeGroupList(self):
self.groupList.clear()
self.groupList.setAlternatingRowColors(True)
self.groupList.setIconSize(
QSize(KIconLoader.SizeLarge, KIconLoader.SizeLarge))
self.groupList.setState(self.state)
self.groupList.addGroups(self.state.groups())
self.groupFilter()
def packageFilter(self, text):
self.packageList.model().setFilterRole(Qt.DisplayRole)
self.packageList.model().setFilterRegExp(
QRegExp(unicode(text), Qt.CaseInsensitive, QRegExp.FixedString))
def groupFilter(self):
self.setSelectAll()
self.packageList.resetMoreInfoRow()
packages = self.state.groupPackages(self.groupList.currentGroup())
self.packageList.model().setFilterRole(GroupRole)
waitCursor()
self.packageList.model().setFilterPackages(packages)
restoreCursor()
def searchActivated(self):
self.setSelectAll()
self.packageList.resetMoreInfoRow()
waitCursor()
packages = self.packageList.search(str(self.searchLine.text()).split())
self.packageList.model().setFilterRole(GroupRole)
self.packageList.model().setFilterPackages(packages)
restoreCursor()
def setActionButton(self):
self.actionButton.setEnabled(False)
self.actionButton.setText(self.state.getActionName())
self.actionButton.setIcon(self.state.getActionIcon())
def actionStarted(self, operation):
totalPackages = self.packageList.packageCount()
self.operation.setTotalPackages(totalPackages)
self.progressDialog.reset()
self.progressDialog.updateStatus(0, totalPackages, self.state.toBe())
if self.isVisible():
if operation in [
"System.Manager.updateRepository",
"System.Manager.updateAllRepositories"
]:
self.progressDialog.repoOperationView()
self.progressDialog.show()
self.progressDialog.enableCancel()
def exceptionCaught(self, message):
self.progressDialog.hide()
if "urlopen error" in message or "Socket Error" in message:
errorTitle = i18n("Network Error")
errorMessage = i18n(
"Please check your network connections and try again.")
elif "Access denied" in message or "tr.org.pardus.comar.Comar.PolicyKit" in message:
errorTitle = i18n("Authorization Error")
errorMessage = i18n("You are not authorized for this operation.")
elif "HTTP Error 404":
errorTitle = i18n("Pisi Error")
errorMessage = i18n(
"Package not found. It may be upgraded in or removed from the repository. Please try upgrading repository informations."
)
else:
errorTitle = i18n("Pisi Error")
errorMessage = message
self.messageBox = QtGui.QMessageBox(errorTitle, errorMessage,
QtGui.QMessageBox.Critical,
QtGui.QMessageBox.Ok, 0, 0)
self.messageBox.show()
def actionFinished(self, operation):
self.searchLine.clear()
self.state.reset()
self.progressDialog.hide()
if operation == "System.Manager.installPackage":
self.showSummary()
if operation in [
"System.Manager.installPackage",
"System.Manager.removePackage", "System.Manager.updatePackage"
]:
self.notifyFinished()
self.initialize()
def notifyFinished(self):
# Since we can not identify the caller yet
if not self.operation.totalPackages:
return
KNotification.event(
"Summary", self.state.getSummaryInfo(self.operation.totalPackages),
QtGui.QPixmap(), None, KNotification.CloseOnTimeout,
KComponentData("package-manager", "package-manager",
KComponentData.SkipMainComponentRegistration))
def showSummary(self):
self.summaryDialog.setDesktopFiles(self.operation.desktopFiles)
if self.summaryDialog.hasApplication():
self.summaryDialog.show()
def setActionEnabled(self):
enabled = self.packageList.isSelected()
self.actionButton.setEnabled(enabled)
self.basket.setActionEnabled(enabled)
def switchState(self, state, action=True):
self.setSelectAll()
self.searchLine.clear()
self.state.setState(state)
self.setActionButton()
if action:
self.state.stateAction()
def emitStatusBarInfo(self, packages, packagesSize, extraPackages,
extraPackagesSize):
self.emit(
SIGNAL("selectionStatusChanged(QString)"),
self.state.statusText(packages, packagesSize, extraPackages,
extraPackagesSize))
def setSelectAll(self, packages=None):
if packages:
self.packageList.reverseSelection(packages)
self.selectAll.setText(i18n("Select all packages in this group"))
self.selectAll.setUrl("All")
def setReverseAll(self, packages=None):
if packages:
self.packageList.selectAll(packages)
self.selectAll.setText(i18n("Reverse package selections"))
self.selectAll.setUrl("Reverse")
def toggleSelectAll(self, text):
packages = self.packageList.model().getFilteredPackages()
if text == "All":
self.setReverseAll(packages)
else:
self.setSelectAll(packages)
self.statusChanged()
def showBasket(self):
waitCursor()
self.statusUpdater.wait()
self.basket.show()
restoreCursor()
def switchSession(self, session):
self.session.setSession(session)
waitCursor()
self.searchLine.clear()
self.progressDialog.hide()
self.state.setState(StateManager.INSTALL)
self.setActionButton()
restoreCursor()
