def handleMainWindowEmits(self, param): #print(param) if param == "SCAN": self._theMainWindow.theScan.clear() self._theMainWindow.theScan.theSelect.clear() self._theMainWindow.theScan.show() elif param == "UPDATE": self._theMainWindow.theUpdate.show() elif param == "HISTORY": self._theMainWindow.theHistory.show() # populating combo boxes availMal = utilities.populateMalware() modelMalware = utilities.malwareModel(availMal) self._theMainWindow.theHistory.comMalware.setModel(modelMalware) availDBs = utilities.populateVirusDBs() modelDBs = utilities.virusDBModel(availDBs) #populating date fields self.curDateList = date.today().isoformat().split('-') self.curQDate = QDate(int(self.curDateList[0]), int(self.curDateList[1]), int(self.curDateList[2])) self._theMainWindow.theHistory.comStartDate.setDate(self.curQDate ) self._theMainWindow.theHistory.comEndDate.setDate(self.curQDate ) self._theMainWindow.theHistory.comDatabase.setModel(modelDBs) else: QMessageBox.critical(None, langmodule.attention, langmodule.applicationError, QMessageBox.Ok | QMessageBox.Default, QMessageBox.NoButton)
def create_window(window_class, **kwargs): """Create a QT window in Python, or interactively in IPython with QT GUI event loop integration. """ global app app = get_app_qt4(sys.argv) app.references = set() net = None fname = None if len(sys.argv) > 1: fname = sys.argv[1] if os.path.exists(fname): net = read_pickle(fname) else: QMessageBox.critical( None, "Error opening file %s", fname, QMessageBox.Ok, QMessageBox.NoButton) window = window_class(net, fname) app.references.add(window) window.show() start_event_loop_qt4(app) return window
def extractToText(self): try: now = datetime.now().isoformat().split('T') filename='scanLog_' + now[0][0:10] + '_' + now[1][0:8] + '.txt' flags = QFileDialog.DontResolveSymlinks | QFileDialog.ShowDirsOnly folder = QFileDialog.getExistingDirectory(self._theMainWindow.theHistory.theResults, langmodule.chooseFolderToStoreText, homeDir, flags) print(filename) print(manager._resultsToPrint) path = folder + '/' + filename with open(path, 'w') as file: file.write(langmodule.userTitle + '\t\t\t' + langmodule.noOfResultsTitle + '\t\t' + langmodule.scanDateTimeTitle + '\n') # linux specific newline - not portable! file.write("----------------------------------------------------------------------------------" + '\n') # linux specific newline - not portable! for inlist in manager._resultsToPrint: file.write(inlist[0] + '\t\t\t') file.write(inlist[1] + '\t\t\t\t\t') file.write(inlist[2] + '\n') # linux specific newline - not portable! file.close() except IOError as error: print(str(error)[0:13]) if "Permission denied" in str(error): QMessageBox.critical(None, langmodule.attention, langmodule.noAccessRightsInFolder, QMessageBox.Ok | QMessageBox.Default, QMessageBox.NoButton) except Exception: QMessageBox.critical(None, langmodule.attention, langmodule.errorStoringFile, QMessageBox.Ok | QMessageBox.Default, QMessageBox.NoButton)
def fetched_usages(self, reply): self.updateButton.setEnabled(True) self.progressBar.setHidden(True) if reply.error() == QNetworkReply.NoError: if not self.usage_model.parse(str(reply.readAll())): title = "Parsing error" message = self.usage_model.error else: title = None self.tree_model.deleteLater() self.tree_model = TreeModel(self.usage_model.usage) self.treeView.setModel(self.tree_model) self.show_lastupdate() self.write_usage() elif reply.error() in [QNetworkReply.AuthenticationRequiredError, QNetworkReply.ContentAccessDenied]: title = "Authentication error" message = "Please check your account credentials." else: title = "An error occured" message = reply.errorString() \ + ".\nPlease check your internet connection." if title: QMessageBox.critical(self, title, message) reply.deleteLater()
def accept(self): self.model.name = self.accountNameEdit.text() username = self.usernameEdit.text() password = self.passwordEdit.text() if not all([username, password]): QMessageBox.critical(self, "Username & Password", "Both the username and password are required.") if not username: self.usernameEdit.setFocus() else: self.passwordEdit.setFocus() return self.model.username = username self.model.password = password try: self.model.capKB = int(self.capEdit.text() or 0) except ValueError: QMessageBox.critical(self, "Invalid value", "Please enter a number in KB for the capacity.") self.capEdit.setFocus() return self.model.start = self.fromDate.date() self.model.end = self.toDate.date() super(AccountDialog, self).accept()
def setup_model(self): db = Db_Instance("edit_associate").get_instance() if not db.open(): self.log.error(db.lastError().text()) message = unicode("Erro de conexão\n\n""Banco de dados indisponível".decode('utf-8')) QMessageBox.critical(self, unicode("Seareiros - Edição de Associado".decode('utf-8')), message) else: self._model = QSqlRelationalTableModel(self, db=db) self._model.setTable("associate") self._act_model = QSqlRelationalTableModel(self, db=db) self._act_model.setTable("associate_in_activity") # TODO: Maybe I should validate these # associate self._model.setFilter("id = " + str(self._record_id)) self._model.select() self._record = self._model.record(0) # activities self._activity_records = [] sql_statement = """SELECT id, description, room, weekday, weektime FROM activity a, associate_in_activity a_a WHERE a.id = a_a.id_activity AND a_a.id_associate = %s """ % str(self._record_id) model_activities = QSqlQueryModel() model_activities.setQuery(sql_statement, db) # checking query validity if not model_activities.lastError().isValid(): self._activity_records = iterate_model(model_activities)
def doActionSageServer(self): server_list_dialog = ServerListDlg(self) #Get a reference to the WorksheetController associated to this window. wsc = self.webViewController().worksheet_controller #Select the server associated to this window, if there is one. if wsc and wsc.server_configuration: server_list_dialog.selectServer(wsc.server_configuration) #Show the dialog. server_list_dialog.exec_() #It's possible that the user will delete all of the servers. It's not clear how to cleanly handle this case. #We choose to give the user a choice to fix the situation. while not ServerConfigurations.server_list: #No servers? message_text = "Guru needs a Sage server configured in order to evaluate cells. " \ "Add a Sage server configuration in the server configuration dialog?" response = QMessageBox.question(self, "Sage Not Configured", message_text, QMessageBox.Yes, QMessageBox.No) if response == QMessageBox.No: return server_list_dialog.exec_() #Execution only reaches this point if there exists a server. server_name = server_list_dialog.ServerListView.currentItem().text() if wsc: new_config = ServerConfigurations.getServerByName(server_name) try: wsc.useServerConfiguration(new_config) except Exception as e: QMessageBox.critical(self, "Error Switching Servers", "Could not switch servers:\n%s" % e.message)
def promptInputPrevNext(self, prev): """ TOWRITE :param `prev`: TOWRITE :type `prev`: bool """ if self.promptInputList: # if(promptInputList.isEmpty()) if prev: QMessageBox.critical(self, self.tr("Prompt Previous Error"), self.tr("The prompt input is empty! Please report this as a bug!")) else: QMessageBox.critical(self, self.tr("Prompt Next Error"), self.tr("The prompt input is empty! Please report this as a bug!")) qDebug("The prompt input is empty! Please report this as a bug!") else: if prev: self.promptInputNum -= 1 # promptInputNum--; else: self.promptInputNum += 1 # promptInputNum++; maxNum = len(self.promptInputList) # int maxNum = promptInputList.size(); if self.promptInputNum < 0: self.promptInputNum = 0 self.mainWin.prompt.setCurrentText("") elif self.promptInputNum >= maxNum: self.promptInputNum = maxNum self.mainWin.prompt.setCurrentText("") else: self.mainWin.prompt.setCurrentText(self.promptInputList[self.promptInputNum])
def __init__(self, parent=None): super(MainWindow, self).__init__(parent) self.setupUi(self) self.setWindowIcon(QIcon(':/ifmon.png')) try: self.model = BandwidthTableModel(self) except dberrors.OperationalError as e: QMessageBox.critical(self, 'Database Error', 'Could not access database.\nERROR: %s' % e) sys.exit(QApplication.exit()) self.tableView.setModel(self.model) self.tableView.horizontalHeader().setResizeMode(QHeaderView.Stretch) self.tableView.horizontalHeader().setResizeMode(0, QHeaderView.ResizeToContents) self.tableView.setAlternatingRowColors(True) self.dateFrom.setDate(self.model.settings.start) self.dateTo.setDate(self.model.settings.start + timedelta(days=29)) self.updateTotal() self.actionAbout.triggered.connect(self.about) self.timer = QTimer() self.timer.setInterval(1000) self.timer.timeout.connect(self.updateUsage) self.timer.start()
def preSupprVerification(self, index): u"""Vérification à effectuer avant d'autoriser à supprimer un item Renvoit False si la suppression est interdite """ sql = """ SELECT COUNT(*) FROM absence WHERE id_intervenant=""" + str(index.sibling(index.row(), 0).data()) req = QSqlQuery() if req.exec_(sql): req.next() nbAbsences = req.record().value(0) if nbAbsences != 0: pl = "" if nbAbsences != 1: pl = "s" QMessageBox.critical(self, "Impossible de suppprimer", u"L'intervenant a encore " + str(nbAbsences) + u" absence" + pl + u" enregistrée" + pl + "<br />" + u"Il faut les supprimer avant") # TODO trouver un moyen de setter l'onglet de l'application # self._ui.tabWidget.setCurrentIndex(1) return False # TODO gérer le else, au moins logger quelque chose return True
def submit_data(self): self._model.insertRow(0) data = self.extract_input() for key,val in data.items(): self._model.setData(self._model.index(0, self.column[key]), val) # try to commit a record if not self._model.submitAll(): self.log.error(self._model.lastError().text()) message = unicode("Erro de transação\n\n""Não foi possível salvar no banco de dados".decode('utf-8')) QMessageBox.critical(self, "Seareiros - Cadastro de Atividade", message) return False else: # successfully added an associate, adding it's activities activities = self.extract_activities_input() error = False if len(activities) > 0: associate_id = self.get_added_record().value("id") for id in activities: self._act_model.insertRow(0) self._act_model.setData(self._act_model.index(0, 0), associate_id) self._act_model.setData(self._act_model.index(0, 1), id) ok = self._act_model.submitAll() if not ok: error = True self.log.error(self._act_model.lastError().text()) if not error: message = unicode("Sucesso!\n\n""O associado foi salvo com êxito no banco de dados".decode('utf-8')) QMessageBox.information(self, "Seareiros - Cadastro de Associado", message) else: message = unicode("Erro\n\n""Associado cadastrado, " "porém ocorreu um problema ao salvar suas atividades".decode('utf-8')) QMessageBox.warning(self, "Seareiros - Cadastro de Associado", message) return True
def setup_model(self): db = Db_Instance("form_book").get_instance() if not db.open(): self.log.error(db.lastError().text()) message = unicode("Erro de conexão\n\n" "Banco de dados indisponível".decode("utf-8")) QMessageBox.critical(self, "Seareiros - Cadastro de Livro", message) else: # book self._model = QSqlTableModel(self, db=db) self._model.setTable("book") # subject self._subject_model = QSqlTableModel(self, db=db) self._subject_model.setTable("subject") self._subject_model.select() # author self._author_model = QSqlTableModel(self, db=db) self._author_model.setTable("author") self._author_model.select() # sauthor self._s_author_model = QSqlTableModel(self, db=db) self._s_author_model.setTable("s_author") self._s_author_model.select() # publisher self._publisher_model = QSqlTableModel(self, db=db) self._publisher_model.setTable("publisher") self._publisher_model.select() # book subjects self._book_in_subj_model = QSqlTableModel(self, db=db) self._book_in_subj_model.setTable("book_in_subject")
def confirmSubs(self, playersIn, playersOut, datetime): week = gameinfo.weekNum(datetime) + 1 date = gameinfo.weekToDate(week).date() html = render_to_string('subs_email.html', {'team': self.team, 'players_in': playersIn, 'players_out': playersOut, 'week': week, 'date': date} ) settings = QSettings() if settings.contains('SMTP/Server'): smtp_server = settings.value('SMTP/Server') else: smtp_server = None if not smtp_server: QMessageBox.critical(self, "Email Error", "Please add an SMTP server in settings.") else: email = HTMLEmail([self.team.email], "*****@*****.**", "Fantasy Football League", bcc='*****@*****.**') email.sendMail("Sub Confirmation", html, smtp_server)
def accept(self): players = self.playerSelections() self.team.team_name = self.teamNameEdit.text() self.team.email = unicode(self.emailEdit.text()).lower() if self.validTeam(players): playersOut = [player for player in self.team_players if player not in players] subs_made = len(playersOut) if subs_made > 0: if self.team.subs_used + subs_made > config.MAX_SUBS: QMessageBox.critical(self, "Substitution Error", "This manager has insufficient substitutions remaining") self.setCurrentPlayers() else: playersIn = [player for player in players if player not in self.team_players] form = confirmSubsDialog(playersOut, playersIn, self) if form.exec_(): self.team.subs_used += subs_made self.team.total_cost = self.total_cost self.team.formation = self.formation self.team.squad.substitute(playersIn, playersOut, form.datetime) self.confirmSubs(playersIn, playersOut, form.datetime) QDialog.accept(self) else: self.setCurrentPlayers() else: QDialog.accept(self) self.team.save()
def merge_pdf(destination=None, pdf_files=None): try: output = PdfFileWriter() inputs = [] for pdf_file in pdf_files: reader_pdf_file = PdfFileReader(open(pdf_file, 'rb')) inputs.append(reader_pdf_file) for input_pdf in inputs: for page in input_pdf.pages: output.addPage(page) output_stream = open(destination, 'wb') output.write(output_stream) output_stream.close # merger = PdfFileMerger() # for pdf_file in pdf_files: # merger.append(open(pdf_file, 'rb')) # merger.write(open(destination), 'wb') QMessageBox.information(main, 'Success!', 'PDFs have been merged to ' + destination ) except: QMessageBox.critical(main, 'Error!', 'Critical error occured.\n\n%s' % traceback.format_exc())
def on_addTagsButton_clicked(self): if len(self.tagsInput.text()) == 0: QMessageBox.critical(self, u'错误', u'请至少输入一个类别') else: tags = set(self.tagsInput.text().split()) self.selectedTag.addItems(list(tags-set(self.tags))) self.tags.extend(tags)
def addServer(self): dialog = EditSageServerDlg(self) name_collision = True #The while loop needs to run at least once. while name_collision: if not dialog.exec_(): #The user clicked cancel. return #Fetch the data. new_server = dialog.getServerConfiguration() #Check to see if the name is in use. name_collision = ServerConfigurations.getServerByName(new_server["name"]) #If the user set the name to a new name that is already in use, name_collision will #not be None. The loop will continue and the dialog reopened. if name_collision: #The name is already in use. QMessageBox.critical(self, "Name already exists", "A server configuration already exists with that name. Choose a different name.") dialog.txtName.selectAll() dialog.txtName.setFocus() #Add the server configuration to the list. ServerConfigurations.addServer(new_server) item = QListWidgetItem(new_server["name"], self.ServerListView) self.ServerListView.setCurrentItem(item) if new_server["default"]: self.updateListViewDefault()
def startApplication(self): self.m_server = QLocalServer() if self.m_server.listen(self.applicationName()): self.m_server.newConnection.connect(self.getNewConnection) self.mainWindow.show() else: QMessageBox.critical(None, self.tr("Error"), self.tr("Error listening the socket."))
def loadFile(self, file_name): #Which MainWindow object we create the new worksheet in depends on if loadFile() #is fired on a welcome page or not. Returns True on success. if self.isWelcome: #Use the current MainWindow object to create the worksheet. self.hideWelcome() #Set the working filename self.file_name = file_name #We set the window title. self.setUniqueWindowTitle() #Open the worksheet in the webView. try: self.webViewController().openWorksheetFile(file_name) except Exception as e: QMessageBox.critical(self, "File Open Error", "Could not open the file:\n%s" % e.message) self.showWelcome() return False #Set the dirty flag handler. self.dirty(False) self.connectWorksheetSignals() self.updateRecentFilesMenu() else: #Create a new MainWindow object to use for the new worksheet. main_window = MainWindow(file_name=file_name) main_window.show() main_window.activateWindow() main_window.raise_() return True
def check_barcode(self, txt): if len(txt) == self.edBarcode.maxLength(): db = Db_Instance("obook_barcode_search").get_instance() try: if db.open(): query = QSqlQuery(db) query.prepare("SELECT * FROM book WHERE barcode = :barcode") query.bindValue(":barcode", txt) query.exec_() if query.next(): self.add_book_from_record(query.record()) self.edBarcode.clear() else: raise RecordNotFoundException else: raise DbUnavailableException except RecordNotFoundException: message = unicode("Código de barra inválido!\n\n""" "O código informado não corresponde a nenhum livro cadastrado".decode('utf-8')) QMessageBox.critical(self, "Seareiros - Livraria", message) except DbUnavailableException: self.log.error(db.lastError().text()) message = unicode("Erro de conexão\n\n""Banco de dados indisponível".decode('utf-8')) QMessageBox.critical(self, "Seareiros - Livraria", message) self.edBarcode.setFocus()
def importNominalPositions(self): fn, filt = QFileDialog.getOpenFileName(self, "Open Excel File", "", "Excel Files(*.xls)") if not fn: return try: wb = xlrd.open_workbook(fn) except: QMessageBox.critical(self, "Invalid Excel file", "Pyrite could not " "parse the selected Excel file. Make sure it is the .xls not " ".xlsx format.") return dlg = ExcelRegionSelector(self, wb.sheet_names()) dlg.exec_() if dlg.result() != QDialog.Accepted: return xRow = dlg.xRow xCol = dlg.xCol yRow = dlg.yRow yCol = dlg.yCol count = dlg.count sheetName = dlg.sheetName sheet = wb.sheet_by_name(sheetName) # load the nominal positions for i in range(count): pos = (float(sheet.cell(xRow + i, xCol).value), float(sheet.cell(yRow + i, yCol).value)) self._nominalData.append(pos) self._nominalDataLoaded = True self.updateNominalPositionPreview() self.updateGenerateEnabled()
def submit_data(self): # I should block empty orders I guess if len(self._product_list) == 0: message = unicode( "Venda vazia!\n\n" "" "É necessário adicionar um produto antes de concluir uma venda".decode("utf-8") ) QMessageBox.critical(self, "Seareiros - Vendas do Bazar", message) self.edProductName.setFocus() return False data = self.extract_input() # filling a product order self._model.insertRow(0) for key, val in data.items(): self._model.setData(self._model.index(0, self.column[key]), val) order_id = submit_and_get_id(self, self._model, self.log) if order_id: # order creation success, placing items error = False for item in self._product_list: product_name = item[0] product_price = item[1] product_quantity = item[2] self._items_model.insertRow(0) self._items_model.setData(self._items_model.index(0, 1), order_id) self._items_model.setData(self._items_model.index(0, 2), product_name) self._items_model.setData(self._items_model.index(0, 3), product_price) self._items_model.setData(self._items_model.index(0, 4), product_quantity) ok = self._items_model.submitAll() if not ok: error = True break if error: self.log.error(self._items_model.lastError().text()) message = unicode( "Erro\n\n" "Venda registrada e contabilizada, porém ocorreu um problema e" " não será possível visualizar seus itens.".decode("utf-8") ) QMessageBox.warning(self, "Seareiros - Vendas do Bazar", message) return False else: # all went fine # retrieving some brief info of the order to display at the main window if "associate" in data: desc = "Venda do bazar no valor de R$ %s para %s" % ( self._locale.toString(data["total"], "f", 2).replace(".", ""), self.lblNickname.text(), ) else: desc = "Venda do bazar no valor de R$ %s" % self._locale.toString(data["total"], "f", 2).replace( ".", "" ) if not log_to_history(self._model.database(), "venda_bazar", order_id, desc): self.log.error(self._model.lastError().text()) message = unicode("Sucesso!\n\n" "Venda concluída.".decode("utf-8")) QMessageBox.information(self, "Seareiros - Vendas do Bazar", message) return True # failed to insert a row return False
def wrapper(self, *args, **kwargs): try: return f(self, *args, **kwargs) except Exception as e: parent = self if isinstance(self, QWidget) else None QMessageBox.critical(parent, u'An error occurred', u'An error occurred:\n{0}'.format(e)) raise
def _onStart(self): outputdir = self._txt_outputdir.path() if not outputdir: QMessageBox.critical(self, 'Start', 'Missing output directory') return max_workers = self._spn_workers.value() overwrite = self._chk_overwrite.isChecked() self.start(outputdir, overwrite, max_workers)
def authenticate(self): password = self.pwd.text() uid = self.email.text() savecreds = self.savecreds.isChecked() if QCoreApplication.instance().authenticate(uid, password, savecreds): self.accept() else: QMessageBox.critical(self, "Wrong Password", "The user ID and password entered do not match.")
def openDocumentFile(self, filePath): try: # TODO: Improve error messages, e.g. to include line numbers. doc = DocumentFileFormat.readDocument(filePath) except Exception, e: message = 'File open failed.\n\n' + str(e) QMessageBox.critical(self, '', message)
def doubleClicked(self, vobj): doc = FreeCADGui.getDocument(vobj.Object.Document) if not doc.getInEdit(): doc.setEdit(vobj.Object.Name) else: from PySide.QtGui import QMessageBox message = 'Active Task Dialog found! Please close this one before opening a new one!' QMessageBox.critical(None, "Error in tree view", message) FreeCAD.Console.PrintError(message + '\n') return True
def save(self): file_name = QFileDialog.getSaveFileName(self)[0] if file_name != '': try: with open(file_name, mode='wt') as out_file: text = self._text_edit.toPlainText() out_file.write(text) except: QMessageBox.critical(self, self.tr('Error'), self.tr('Could not save file'))
def open(self): file_name = QFileDialog.getOpenFileName(self)[0] if file_name != '': try: with open(file_name, mode='rt') as in_file: text = in_file.read() self._text_edit.setText(text) except: QMessageBox.critical(self, self.tr('Error'), self.tr('Could not open file'))
def setup_model(self): db = Db_Instance("form_associate").get_instance() if not db.open(): self.log.error(db.lastError().text()) message = unicode("Erro de conexão\n\n""Banco de dados indisponível".decode('utf-8')) QMessageBox.critical(self, "Seareiros - Cadastro de Associado", message) else: self._model = QSqlRelationalTableModel(self, db=db) self._model.setTable("associate") self._act_model = QSqlRelationalTableModel(self, db=db) self._act_model.setTable("associate_in_activity")
def toggleSniffing(self): """ This starts and stops sniffing for a specific sniffer tab. Instances of :class:`~src.ItemAdderThread.ItemAdderThread` and :class:`~src.SnifferProcess.SnifferProcess` are used to gather and display data. """ if self.CANData is None: QMessageBox.critical( Globals.ui.tabWidgetMain, Strings.snifferTabElementInterfaceMissingMessageBoxTitle, Strings.snifferTabElementInterfaceMissingMessageBoxText, QMessageBox.Ok) return # Stop the thread and process if self.active: self.terminateThreads() # If too much data was received process it now if self.tooMuchData: progressDialog = Toolbox.Toolbox.getWorkingDialog( Strings.snifferTabElementDialogProcessing) progressDialog.open() try: self.packetTableModel.clear() for listIdx in range(len(self.valueListsToProcess)): if listIdx % 1500 == 0: QtCore.QCoreApplication.processEvents() self.addPacket(self.valueListsToProcess[listIdx], ignorePacketRate=True) finally: progressDialog.close() self.packetTableView.setEnabled(True) self.tooMuchData = False # Start sniffer process, item generator process and item adder thread else: # Reset the flag self.sharedSnifferEnabledFlag = Value("i", 1) snifferReceivePipe, snifferSendPipe = Pipe() # First start the ItemAdderThread... self.itemAdderThread = ItemAdderThread.ItemAdderThread( snifferReceivePipe, self.packetTableModel, self.rawData, useTimestamp=True) self.itemAdderThread.appendRow.connect(self.addPacket) self.itemAdderThread.start() # ... then start the SnifferProcess self.snifferProcess = SnifferProcess.SnifferProcess( snifferSendPipe, self.sharedSnifferEnabledFlag, self.tabName, CANData=self.CANData) self.snifferProcess.start() SnifferTabElement.amountThreadsRunning += 1 self.updateStatusBar() self.tabWidget.buttonSniff.setText( Strings.snifferTabElementSniffingButtonEnabled) self.active = True self.CANData.active = True self.toggleActive() self.logger.info(Strings.snifferTabElementSniffingStarted)
print("Too many arguments - Exiting") sys.exit(1) elif len(sys.argv) == 2: if sys.argv[1] != "--debug": print("Unknown argument - Exiting") sys.exit(1) else: config.init_config(True) else: config.init_config() langmodule.setuplang() if not utilities.isAVGDRunning(): QMessageBox.critical(None, langmodule.attention, langmodule.avgnotrunning, QMessageBox.Ok | QMessageBox.Default, QMessageBox.NoButton) #print(langmodule.avgnotrunning) exit(1) signal.signal(signal.SIGALRM, avgstopped_handler) mainpid = os.getpid() theApp = theApplication() theApp.theWindow.show() gc.enable() try: subprocess.call([config.daemonMonitor, "--start", str(mainpid)]) except Exception as exc: QMessageBox.critical(None, langmodule.attention,
def avgstopped_handler(signum, frame): QMessageBox.critical(None, langmodule.attention, langmodule.avgStopped, QMessageBox.Ok | QMessageBox.Default, QMessageBox.NoButton) app.exit(1)
def errorMsg(self, msg="Something went wrong !"): QMessageBox.critical(self, "Error", msg) return True
def send_tx(self, amount, address, payment_id, priority, mixin, tx_desc, save_address, sweep_all): if not payment_id and not address.startswith("Sumi"): result = QMessageBox.question(self.ui, "Sending Coins Without Payment ID?", \ "Are you sure to send coins without Payment ID?", \ QMessageBox.Yes | QMessageBox.No, defaultButton=QMessageBox.No) if result == QMessageBox.No: return if sweep_all: result = QMessageBox.question(self.ui, "Sending all your coins?", \ "This will send all your coins to target address.<br><br>Are you sure you want to proceed?", \ QMessageBox.Yes | QMessageBox.No, defaultButton=QMessageBox.No) if result == QMessageBox.No: return wallet_password, result = self._custom_input_dialog(self.ui, \ "Wallet Password", "Please enter wallet password:"******"Incorrect Wallet Password", "Wallet password is not correct!") return self.on_wallet_send_tx_start_event.emit() amount = int(amount * COIN) if sweep_all: _, _, per_subaddress = self.ui.wallet_rpc_manager.rpc_request.get_balance( ) subaddr_indices = [] for s in per_subaddress: if s['unlocked_balance'] > 0: subaddr_indices.append(s['address_index']) ret = self.ui.wallet_rpc_manager.rpc_request.transfer_all( address, payment_id, priority, mixin, 0, subaddr_indices) else: ret = self.ui.wallet_rpc_manager.rpc_request.transfer_split(amount, \ address, payment_id, priority, mixin) if ret['status'] == "ERROR": self.on_wallet_send_tx_completed_event.emit(json.dumps(ret)) self.app_process_events() if ret['message'] == "tx not possible": msg = "Not possible to send coins. Probably, there is not enough money left for fee." else: msg = ret['message'] QMessageBox.critical(self.ui, \ 'Error Sending Coins',\ "<b>ERROR</b><br><br>" + msg) if ret['status'] == "OK": if tx_desc: # set the same note for all txs: notes = [] for i in range(len(ret['tx_hash_list'])): notes.append(tx_desc) self.ui.wallet_rpc_manager.rpc_request.set_tx_notes( ret['tx_hash_list'], notes) self.on_wallet_send_tx_completed_event.emit(json.dumps(ret)) self.app_process_events() msg = "<b>Coins successfully sent in the following transaction(s):</b><br><br>" for i in range(len(ret['tx_hash_list'])): if sweep_all: msg += "- Transaction ID: %s <br>" % ( ret['tx_hash_list'][i]) else: msg += "- Transaction ID: %s <br> - Amount: %s <br> - Fee: %s <br><br>" % (ret['tx_hash_list'][i], \ print_money2(ret['amount_list'][i]), \ print_money2(ret['fee_list'][i])) QMessageBox.information(self.ui, 'Coins Sent', msg) self.ui.update_wallet_info() if save_address: desc, _ = self._custom_input_dialog(self.ui, \ 'Saving Address...', \ "Address description/note (optional):") ret = self.ui.wallet_rpc_manager.rpc_request.add_address_book(address, \ payment_id, desc) if ret['status'] == "OK": if self.ui.wallet_info.wallet_address_book: address_entry = { "address": address, "payment_id": payment_id, "description": desc[0:200], "index": ret["index"] } self.ui.wallet_info.wallet_address_book.append( address_entry) QMessageBox.information(self.ui, "Address Saved", \ "Address (and payment ID) saved to address book.")
class Hub(QObject): current_block_height = 0 def __init__(self, app): super(Hub, self).__init__() self.app = app def setUI(self, ui): self.ui = ui def setNewWalletUI(self, new_wallet_ui): self.new_wallet_ui = new_wallet_ui @Slot() def import_wallet(self): dlg = QFileDialog(self.new_wallet_ui, "Select Import Wallet File") dlg.setFileMode(QFileDialog.ExistingFile) wallet_filename = None if dlg.exec_(): wallet_filename = dlg.selectedFiles()[0] else: return new_wallet_file = os.path.join(wallet_dir_path, self.get_new_wallet_file_name()) if wallet_filename: wallet_key_filename = wallet_filename + '.keys' if not os.path.exists(wallet_key_filename): QMessageBox.warning(self.new_wallet_ui, \ 'Import Wallet',\ """Error: Key file does not exist!<br> Are you sure to select correct wallet file?<br><br> Hint: Wallet file often ends with .bin""") return False try: copy2(wallet_filename, os.path.join(wallet_dir_path, new_wallet_file)) copy2(wallet_key_filename, os.path.join(wallet_dir_path, \ new_wallet_file + '.keys')) except IOError, err: self._detail_error_msg("Importing Wallet", "Error importing wallet!", str(err)) self.ui.reset_wallet() return False if not os.path.exists(new_wallet_file): return False wallet_password = None while True: wallet_password, result = self._custom_input_dialog(self.new_wallet_ui, \ "Wallet Password", "Enter password of the imported wallet:", QLineEdit.Password) if result: if not wallet_password: QMessageBox.warning(self.new_wallet_ui, \ 'Wallet Password',\ "You must provide password to open the imported wallet") else: break else: return False self.on_new_wallet_show_progress_event.emit('Importing wallet...') self.app_process_events() ret = self.ui.wallet_rpc_manager.rpc_request.open_wallet( os.path.basename(new_wallet_file), wallet_password) if ret['status'] == "ERROR": error_message = ret['message'] QMessageBox.critical(self.new_wallet_ui, \ 'Error Importing Wallet',\ "Error: %s" % error_message) self.ui.reset_wallet() return False self.current_block_height = 0 # reset current wallet block height self.ui.wallet_info.wallet_password = hashlib.sha256( wallet_password).hexdigest() self.ui.wallet_info.wallet_filepath = new_wallet_file self.ui.wallet_info.is_loaded = True self.ui.wallet_info.save() self.show_wallet_info() return True
def open_existing_wallet(self): current_wallet_password, result = self._custom_input_dialog(self.ui, \ "Wallet Password", "Current wallet password:"******"Incorrect Wallet Password", "Wallet password is not correct!") return dlg = QFileDialog(self.ui, "Open Wallet File", wallet_dir_path, "Wallet files (*.bin)") dlg.setFileMode(QFileDialog.ExistingFile) wallet_filename = None if dlg.exec_(): wallet_filename = dlg.selectedFiles()[0] else: self.on_open_existing_wallet_complete_event.emit() return if not wallet_filename: return wallet_key_filename = wallet_filename + '.keys' if not os.path.exists(wallet_key_filename): QMessageBox.warning(self.ui, \ 'Open Wallet File',\ """Error: Key file does not exist!<br> Please make sure to select correct wallet file""") return if os.path.normpath(os.path.dirname( wallet_filename)) != os.path.normpath(wallet_dir_path): QMessageBox.warning(self.ui, \ 'Open Wallet File',\ """Error: Only wallet files at default location are available for opening.<br> You can import wallet via 'New... > Import' feature instead.""") return if os.path.basename(wallet_filename) == os.path.basename( self.ui.wallet_info.wallet_filepath): QMessageBox.warning(self.ui, \ 'Open Wallet File',\ """Error: Cannot open the same wallet!""") return while True: wallet_password, result = self._custom_input_dialog(self.ui, \ "Wallet Password", "Enter wallet password for opening:", QLineEdit.Password) if result: if not wallet_password: QMessageBox.warning(self.ui, \ 'Wallet Password',\ "You must provide password to open wallet") continue else: break else: return self.ui.stop_update_wallet_info_timer() self.on_open_existing_wallet_start_event.emit() current_wallet_filename = self.ui.wallet_info.wallet_filepath try: ret = self.ui.wallet_rpc_manager.rpc_request.stop_wallet() if ret['status'] == "ERROR": error_message = ret['message'] QMessageBox.critical(self.ui, \ 'Error Closing Current Wallet',\ "Error: %s" % error_message) raise Exception(error_message) self.ui.wallet_rpc_manager.set_ready(False) self.ui.run_wallet_rpc() while not self.ui.wallet_rpc_manager.is_ready(): self.app_process_events(0.1) ret = self.ui.wallet_rpc_manager.rpc_request.open_wallet( os.path.basename(wallet_filename), wallet_password) if ret['status'] == "ERROR": error_message = ret['message'] QMessageBox.critical(self.ui, 'Error Opening Wallet', error_message) raise Exception(error_message) self.ui.reset_wallet(False) self.ui.wallet_info.wallet_password = hashlib.sha256( wallet_password).hexdigest() self.ui.wallet_info.wallet_filepath = wallet_filename self.ui.wallet_info.is_loaded = True self.ui.wallet_info.save() while not self.ui.wallet_rpc_manager.is_ready(): self.app_process_events(0.1) except Exception, err: log(str(err), LEVEL_ERROR) ret = self.ui.wallet_rpc_manager.rpc_request.open_wallet( os.path.basename(current_wallet_filename), current_wallet_password) self.ui.wallet_info.wallet_password = hashlib.sha256( current_wallet_password).hexdigest() self.ui.wallet_info.wallet_filepath = current_wallet_filename self.ui.wallet_info.is_loaded = True self.ui.wallet_info.save() self.on_open_existing_wallet_complete_event.emit()
def change_wallet_password(self): old_password, result = self._custom_input_dialog(self.ui, \ "Wallet Password", "Enter current wallet password:"******"", "") QMessageBox.warning(self.ui, "Incorrect Wallet Password", "Wallet password is not correct!") return new_password = None while True: new_password, result = self._custom_input_dialog(self.ui, \ "Wallet New Password", "Set new wallet password:"******"Password must contain at least 1 character [a-zA-Z] or number [0-9]\ <br>or special character like !@#$%^&* and not contain spaces" ) continue confirm_password, result = self._custom_input_dialog(self.ui, \ 'Wallet New Password', \ "Confirm new wallet password:"******"Confirm password does not match new password!\ <br>Please re-enter password" ) continue else: break else: return else: return if new_password is not None: if new_password == old_password: QMessageBox.information( self.ui, "Wallet Password", "New wallet password is the same as old one. Nothing changed!" ) return ret = self.ui.wallet_rpc_manager.rpc_request.change_wallet_password( old_password, new_password) if ret['status'] == "ERROR": error_message = ret['message'] QMessageBox.critical(self.ui, \ 'Error Changing Wallet Password',\ "Error: %s" % error_message) return self.ui.wallet_info.wallet_password = hashlib.sha256( new_password).hexdigest() self.ui.wallet_info.save() QMessageBox.information( self.ui, "Wallet Password Changed", "Wallet password successfully changed!<br>Please make sure you never lose it." )
def restore_deterministic_wallet(self, mnemonic_seed, restore_height=0, seed_offset_passphrase=u''): from settings.electrum_words import find_seed_language language_name, english_seed = find_seed_language(mnemonic_seed) if language_name is None: QMessageBox.critical(self.new_wallet_ui, \ 'Error Restoring Wallet',\ """ERROR: Invalid mnemonic seed!<br> Seed words missing, incorrect or not match any language<br><br> NOTE: Sumokoin mnemonic seed must be a list of 26 (valid) words""") return if restore_height > 0: ret = QMessageBox.warning(self.new_wallet_ui, \ 'Restore Wallet',\ """Are you sure to restore wallet from blockchain height# %d?<br><br> WARNING: Incorrect height# will lead to incorrect balance and failed transactions!""" % restore_height, \ QMessageBox.Yes|QMessageBox.No, defaultButton = QMessageBox.No) if ret == QMessageBox.No: return wallet_password = None try: has_password = False while True: wallet_password, result = self._custom_input_dialog(self.new_wallet_ui, \ "Wallet Password", "Set new wallet password:"******"Password must contain at least 1 character [a-zA-Z] or number [0-9]\ <br>or special character like !@#$%^&* and not contain spaces" ) continue confirm_password, result = self._custom_input_dialog(self.new_wallet_ui, \ 'Wallet Password', \ "Confirm wallet password:"******"Confirm password does not match password!\ <br>Please re-enter password" ) else: has_password = True break else: break else: break if has_password: self.on_new_wallet_show_progress_event.emit( "Restoring wallet...") self.app_process_events(0.1) wallet_filename = self.get_new_wallet_file_name() wallet_filepath = os.path.join(wallet_dir_path, wallet_filename) while not self.ui.wallet_rpc_manager.is_ready(): self.app_process_events(0.1) ret = self.ui.wallet_rpc_manager.rpc_request.restore_deterministic_wallet( english_seed, restore_height, wallet_filename, seed_offset_passphrase, wallet_password, "English") if ret['status'] == "ERROR": error_message = ret['message'] QMessageBox.critical(self.new_wallet_ui, \ 'Error Restoring Wallet',\ "Error: %s" % error_message) raise Exception("Error restoring wallet: %s" % error_message) ret = self.ui.wallet_rpc_manager.rpc_request.set_wallet_seed_language( language_name) if ret['status'] == "ERROR": error_message = ret['message'] QMessageBox.critical(self.new_wallet_ui, \ 'Error Restoring Wallet',\ "Error setting seed language: %s" % error_message) raise Exception("Error restoring wallet: %s" % error_message) self.ui.wallet_info.wallet_filepath = wallet_filepath self.ui.wallet_info.wallet_password = hashlib.sha256( wallet_password).hexdigest() self.ui.wallet_info.is_loaded = True self.ui.wallet_info.save() self.current_block_height = 0 # reset current wallet block height self.ui.wallet_rpc_manager.set_ready(False) while not self.ui.wallet_rpc_manager.is_ready(): self.app_process_events(1) h = self.ui.wallet_rpc_manager.get_block_height() if h > 0: block_hash = self.ui.wallet_rpc_manager.get_block_hash( ) self.on_new_wallet_update_processed_block_height_event.emit( h, self.ui.current_height, block_hash) self.show_wallet_info() except Exception, err: log(str(err), LEVEL_ERROR) self.ui.reset_wallet(delete_files=False) return
def create_new_wallet(self): wallet_password = None wallet_filepath = "" try: has_password = False while True: wallet_password, result = self._custom_input_dialog(self.new_wallet_ui, \ "Wallet Password", "Set new wallet password:"******"Password must contain at least 1 character [a-zA-Z] or number [0-9]\ <br>or special character like !@#$%^&* and not contain spaces" ) continue confirm_password, result = self._custom_input_dialog(self.new_wallet_ui, \ 'Wallet Password', \ "Confirm wallet password:"******"Confirm password does not match password!\ <br>Please re-enter password" ) else: has_password = True break else: break else: break if has_password: mnemonic_seed_language = "English" seed_language_list = [sl[1] for sl in seed_languages] list_select_index = 1 lang, ok = QInputDialog.getItem( self.new_wallet_ui, "Mnemonic Seed Language", "Select a language for wallet mnemonic seed:", seed_language_list, list_select_index, False) if ok and lang: for sl in seed_languages: if sl[1] == lang: mnemonic_seed_language = sl[0] break else: return self.on_new_wallet_show_progress_event.emit( "Creating wallet...") self.app_process_events(0.1) wallet_filename = self.get_new_wallet_file_name() wallet_filepath = os.path.join(wallet_dir_path, wallet_filename) while not self.ui.wallet_rpc_manager.is_ready(): self.app_process_events(0.1) ret = self.ui.wallet_rpc_manager.rpc_request.create_wallet( wallet_filename, wallet_password, mnemonic_seed_language) if ret['status'] == "ERROR": error_message = ret['message'] QMessageBox.critical(self.new_wallet_ui, \ 'Error Creating Wallet',\ "Error: %s" % error_message) raise Exception("Error creating wallet: %s" % error_message) self.current_block_height = 0 # reset current wallet block height self.ui.wallet_info.wallet_filepath = wallet_filepath self.ui.wallet_info.wallet_password = hashlib.sha256( wallet_password).hexdigest() self.ui.wallet_info.is_loaded = True self.ui.wallet_info.save() self.show_wallet_info() except Exception, err: log(str(err), LEVEL_ERROR) self.ui.reset_wallet(delete_files=False) self.on_new_wallet_ui_reset_event.emit() return
def show_error(self, text): """ :return: pops up an error """ QMessageBox.critical(QMessageBox(), "Fail!!", "Please Enter %s properly" % text, QMessageBox.Ok)
def doubleClicked(self, vobj): # Group meshing is only active on active analysis # we should make sure the analysis the mesh belongs too is active gui_doc = FreeCADGui.getDocument(vobj.Object.Document) if not gui_doc.getInEdit(): # may be go the other way around and just activate the # analysis the user has doubleClicked on ?! # not a fast one, we need to iterate over all member of all # analysis to know to which analysis the object belongs too!!! # first check if there is an analysis in the active document found_an_analysis = False for o in gui_doc.Document.Objects: if o.isDerivedFrom("Fem::FemAnalysisPython"): found_an_analysis = True break if found_an_analysis: if FemGui.getActiveAnalysis() is not None: if FemGui.getActiveAnalysis( ).Document is FreeCAD.ActiveDocument: if self.Object in FemGui.getActiveAnalysis().Group: if not gui_doc.getInEdit(): gui_doc.setEdit(vobj.Object.Name) else: FreeCAD.Console.PrintError( "Activate the analysis this Gmsh FEM " "mesh object belongs too!\n") else: print( "Gmsh FEM mesh object does not belong to the active analysis." ) found_mesh_analysis = False for o in gui_doc.Document.Objects: if o.isDerivedFrom("Fem::FemAnalysisPython"): for m in o.Group: if m == self.Object: found_mesh_analysis = True FemGui.setActiveAnalysis(o) print( "The analysis the Gmsh FEM mesh object " "belongs to was found and activated: {}" .format(o.Name)) gui_doc.setEdit(vobj.Object.Name) break if not found_mesh_analysis: print( "Gmsh FEM mesh object does not belong to an analysis. " "Analysis group meshing will be deactivated." ) gui_doc.setEdit(vobj.Object.Name) else: FreeCAD.Console.PrintError( "Active analysis is not in active document.") else: print( "No active analysis in active document, " "we are going to have a look if the Gmsh FEM mesh object " "belongs to a non active analysis.") found_mesh_analysis = False for o in gui_doc.Document.Objects: if o.isDerivedFrom("Fem::FemAnalysisPython"): for m in o.Group: if m == self.Object: found_mesh_analysis = True FemGui.setActiveAnalysis(o) print( "The analysis the Gmsh FEM mesh object " "belongs to was found and activated: {}" .format(o.Name)) gui_doc.setEdit(vobj.Object.Name) break if not found_mesh_analysis: print( "Gmsh FEM mesh object does not belong to an analysis. " "Analysis group meshing will be deactivated.") gui_doc.setEdit(vobj.Object.Name) else: print("No analysis in the active document.") gui_doc.setEdit(vobj.Object.Name) else: from PySide.QtGui import QMessageBox message = "Active Task Dialog found! Please close this one before opening a new one!" QMessageBox.critical(None, "Error in tree view", message) FreeCAD.Console.PrintError(message + "\n") return True