class UpdateDialog(QDialog): """The dialog for update.""" def __init__(self): super(UpdateDialog, self).__init__() vbox = QVBoxLayout(self) self.closed = False self.setModal(True) self.resize(500, 250) vbox.addWidget(QLabel(u"Actualización de la lista de episodios:")) self.text = QPlainTextEdit() self.text.setReadOnly(True) vbox.addWidget(self.text) bbox = QDialogButtonBox(QDialogButtonBox.Cancel) bbox.rejected.connect(self.reject) vbox.addWidget(bbox) def append(self, text): """Append some text in the dialog.""" self.text.appendPlainText(text.strip()) def closeEvent(self, event): """It was closed.""" self.closed = True
class LogDialog(QDialog): def __init__(self, parent, rpt_file_path): self.rpt_file_path = rpt_file_path QDialog.__init__(self, parent) self.setWindowTitle('Log: ' + self.rpt_file_path) main_lay = QVBoxLayout(self) self.txt_log = QPlainTextEdit(self) self.txt_log.setMinimumWidth(500) self.txt_log.setMinimumHeight(300) main_lay.addWidget(self.txt_log) self.btn_close = QPushButton('Close') self.btn_close.clicked.connect(self.close_dialog) main_lay.addWidget(self.btn_close) self.fill_txt() def close_dialog(self): self.close() def fill_txt(self): with codecs.open(self.rpt_file_path, 'r', encoding='UTF-8') as inp_f: lines = inp_f.read().splitlines() for line in lines: self.txt_log.appendPlainText(line.replace('\b', '')) # Scroll up self.txt_log.moveCursor(QTextCursor.Start) self.txt_log.ensureCursorVisible()
class DumpWindow(QDialog): def __init__(self, parent, uri): QDialog.__init__(self, parent) if uri.startswith('unix://'): self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) self.sock.connect(uri[len('unix://'):]) elif uri.startswith('tcp://'): self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) parsed = re.split('[:/]', uri[len('tcp://'):]) addr = (parsed[0], int(parsed[1])) self.sock.connect(addr) else: raise Exception('Unsupported server URI `%s' % uri) self.sock.setblocking(False) self.fLayout = QVBoxLayout(self) self.setLayout(self.fLayout) self.fTextArea = QPlainTextEdit(self) self.fLayout.addWidget(self.fTextArea) self.resize(500, 600) self.setWindowTitle(self.tr("Dump Window")) self.fTimerId = self.startTimer(100) self.fTmpData = b"" def __del__(self): self.sock.close() def timerEvent(self, event): if event.timerId() == self.fTimerId: self.dump() QDialog.timerEvent(self, event) def dump(self): while True: try: c = self.sock.recv(1) except: break if c == b"\n": self.fTextArea.appendPlainText(str(self.fTmpData, encoding="utf-8", errors="ignore")) self.fTmpData = b"" else: self.fTmpData += c
class TextLogger(logging.Handler): ''' A logger to record the users actions and write them to a QPlainTextEdit widget. ''' def __init__(self, parent): super(TextLogger, self).__init__() self.widget = QPlainTextEdit(parent) self.widget.setReadOnly(True) def emit(self, record): ''' Log a message. Args: record (str) : the message to log. ''' message = self.format(record) self.widget.appendPlainText(message)
def print_result(self, result, history): """ Print processing result """ self.result = result self.history = history message = "Filter " + self.history['process'] + " params: " for param in self.history['params'].keys(): message += " " + param + " : " + str( self.history['params'][param]) + " |" self.historyBox.appendPlainText(message) if result['type'] == "sensor": self.draw_chart(self.result['data']) elif result['type'] == "sensor list": self.draw_multiple_chart(self.result['data']) elif result['type'] == "dict list": field = QPlainTextEdit() field.setReadOnly(True) for elem in self.result['data']: tmp = "" for key in elem.keys(): tmp += key + " : " + str(elem[key]) + " " field.appendPlainText(tmp) self.clear_layout(self.resultFrame.layout()) self.resultFrame.layout().addWidget(field) elif result['type'] == "dict": field = QPlainTextEdit() field.setReadOnly(True) data = self.result['data'] for key in data.keys(): field.appendPlainText(key + " : " + str(data[key])) self.clear_layout(self.resultFrame.layout()) self.resultFrame.layout().addWidget(field) else: print "undefined result" self.base_thread.quit()
class ListEditor(QDialog): def __init__(self, parent=None): """Create layout for the blocked domains""" super(ListEditor, self).__init__(parent) self.setWindowTitle("Website Blocklist") # Create widgets self.tableView = QPlainTextEdit() # if not os.path.isfile(os.path.join(config_dir, 'blocklist')): # self.createBlockFile() # self.loadBlockFile() layout = QVBoxLayout() layout.addWidget(self.tableView) self.saveButton = QPushButton("Done") self.saveButton.clicked.connect(self.closeList) layout.addWidget(self.saveButton, 0, Qt.AlignRight) self.setLayout(layout) def loadBlockFile(self): """If a site block file exists, load it""" file = open(homedir + "blocklist") self.tableView.appendPlainText(file.read()) print(file) file.close() def createBlockFile(self): """Create a new site block file""" file = open(homedir + "blocklist", 'w') file.write("# Add one website per line #\nexample.com\n") file.close() def updateBlocks(self): """Write blocked sites to file""" file = open(homedir + "blocklist", 'w+') file.write(list.tableView.toPlainText()) def closeList(self): """Hide the list""" self.updateBlocks() list.hide()
class ListEditor(QDialog): def __init__(self, parent=None): """Create layout for the blocked domains""" super(ListEditor, self).__init__(parent) self.setWindowTitle("Website Blocklist") # Create widgets self.tableView = QPlainTextEdit() config_dir="~/" if not os.path.isfile(os.path.join(config_dir, 'blocklist')): self.createBlockFile() self.loadBlockFile() layout = QVBoxLayout() layout.addWidget(self.tableView) self.saveButton = QPushButton("Done") self.saveButton.clicked.connect(self.closeList) layout.addWidget(self.saveButton, 0, Qt.AlignRight) self.setLayout(layout) def loadBlockFile(self): """If a site block file exists, load it""" file = open(homedir + "blocklist") self.tableView.appendPlainText(file.read()) file.close() def createBlockFile(self): """Create a new site block file""" file = open(homedir + "blocklist", 'w') file.write("# Add one website per line #\nexample.com\n") file.close() def updateBlocks(self): """Write blocked sites to file""" file = open(homedir + "blocklist", 'w+') file.write(list.tableView.toPlainText()) def closeList(self): """Hide the list""" self.updateBlocks() list.hide()
class ListEditor(QDialog): def __init__(self, parent=None): # Create layout for the blocked domains super(ListEditor, self).__init__(parent) self.setWindowTitle("Website Blocklist") # Create widgets self.tableView = QPlainTextEdit() self.tableView.appendPlainText("# Add one website per line #\nexample.com\n") layout = QVBoxLayout() layout.addWidget(self.tableView) self.saveButton = QPushButton("Done") self.saveButton.clicked.connect(self.closeList) layout.addWidget(self.saveButton, 0, Qt.AlignRight) self.setLayout(layout) def closeList(self): # Hide the list """docstring for closeList""" list.hide()
class SystemLog(object): def __init__(self, display_name, source_name): self.display_name = display_name self.source_name = source_name # FIXME: need to handle rotated logs self.last_filename = os.path.join(get_home_path(), display_name) self.content = '' self.edit = QPlainTextEdit() self.normal_font = self.edit.font() self.monospace_font = QFont('monospace') self.edit.setUndoRedoEnabled(False) self.edit.setReadOnly(True) self.edit.setWordWrapMode(QTextOption.NoWrap) self.edit.setPlainText( 'Click "Refresh" to download {0}.'.format(display_name)) self.monospace_font.setStyleHint(QFont.TypeWriter) def log(self, message, bold=False, pre=False): if bold: self.edit.appendHtml(u'<b>{0}</b>'.format(Qt.escape(message))) elif pre: self.edit.appendHtml(u'<pre>{0}</pre>'.format(message)) else: self.edit.appendPlainText(message) def reset(self): self.content = None self.edit.setPlainText('') self.edit.setFont(self.normal_font) def set_content(self, content): self.content = content self.edit.setPlainText('') self.edit.setFont(self.monospace_font) self.edit.setPlainText(content)
class SystemLog(object): def __init__(self, display_name, source_name): self.display_name = display_name self.source_name = source_name # FIXME: need to handle rotated logs self.last_filename = os.path.join(get_home_path(), display_name) self.content = '' self.edit = QPlainTextEdit() self.normal_font = self.edit.font() self.monospace_font = QFont('monospace') self.edit.setUndoRedoEnabled(False) self.edit.setReadOnly(True) self.edit.setWordWrapMode(QTextOption.NoWrap) self.edit.setPlainText('Click "Refresh" to download {0}.'.format(display_name)) self.monospace_font.setStyleHint(QFont.TypeWriter) def log(self, message, bold=False, pre=False): if bold: self.edit.appendHtml(u'<b>{0}</b>'.format(Qt.escape(message))) elif pre: self.edit.appendHtml(u'<pre>{0}</pre>'.format(message)) else: self.edit.appendPlainText(message) def reset(self): self.content = None self.edit.setPlainText('') self.edit.setFont(self.normal_font) def set_content(self, content): self.content = content self.edit.setPlainText('') self.edit.setFont(self.monospace_font) self.edit.setPlainText(content)
class DebugLogWidget(QWidget): def __init__(self, parent): QWidget.__init__(self, parent) self.canMonitor = parent def addToWidget(self, vbox): self.text = QPlainTextEdit(self.canMonitor) self.text.setReadOnly(True) vbox.addWidget(self.text) hbox = QHBoxLayout() hbox.setAlignment(Qt.AlignRight | Qt.AlignBottom) self.clearButton = QPushButton("Clear", self.canMonitor) self.clearButton.clicked.connect(self._clearText) hbox.addWidget(self.clearButton) vbox.addLayout(hbox) @pyqtSlot() def _clearText(self): self.text.clear() def addLineToLog(self, line): self.text.appendPlainText(line)
class AsciidocEditor(WithSingleIO, QWidget): """Asciidoc editor """ def __init__(self, params, parent=None): self.base_dir = os.path.dirname(__file__) QWidget.__init__(self, parent) self.setMinimumWidth(300) self.setMinimumHeight(300) # create widgets self._editor_widget = mixin( WithFind, WidthMqHighlighter, WithMqEditIO, WithBasicIdentationManager, WithLineHighlight, WithFixedFont, WithLineNumbers, WithViewPortMargins, WithWordCompletionMulty_, WithCompletion, QPlainTextEdit)(self) self.webview = QWebView(self) #self.webview.load(QUrl("/home/maiquel/develop/developing/main/qt/qadoc/bin/__builds/documents.html")) self.splitter = QSplitter(Qt.Horizontal) self.splitter.addWidget(self._editor_widget) self.splitter.addWidget(self.webview) self.splitter.setSizes([self.size().width(), self.size().width()]) self.splitterv = QSplitter(Qt.Vertical) self.splitterv.addWidget(self.splitter) self.log_widget = QPlainTextEdit() self.splitterv.addWidget(self.log_widget) layout = QVBoxLayout(self) layout.addWidget(self.splitterv) layout.setMargin(0) self.setLayout(layout) # proc_compile self.proc_compile = QProcess() self.proc_compile.finished.connect(self.proc_compile_finished) self.proc_compile.error.connect(self.proc_compile_error) self.proc_compile.readyReadStandardOutput.connect(self.proc_compile_readyReadStandardOutput) self.proc_compile.readyReadStandardError.connect(self.proc_compile_readyReadStandardError) WithSingleIO.__init__(self, params) def bw_add_command_list(self, command_list): command_list += [ ("generate preview asciidoc", "pp", 1.0, "self.get_current_widget().command_generate_preview('asciidoc -a toc -a data-uri -a icons -a iconsdir="+self.base_dir+"/adoc/icons/')"), ("generate preview asciidoc style_sheet no images embeded", "pp", 1.0, "self.get_current_widget().command_generate_preview('asciidoc -a toc --attribute stylesheet="+self.base_dir+"/adoc/mq_red.css -a icons -a iconsdir="+self.base_dir+"/adoc/icons/')"), ("generate preview asciidoc style_sheet", "pp", 1.2, "self.get_current_widget().command_generate_preview('asciidoc -a toc --attribute stylesheet="+self.base_dir+"/adoc/mq_red.css -a data-uri -a icons -a iconsdir="+self.base_dir+"/adoc/icons/')"), ("generate preview slidy", "pp slides", 0.8, "self.get_current_widget().command_generate_preview('asciidoc -a toc -b slidy -a data-uri -a icons')"), ("generate preview slidy2", "pp slides", 0.9, "self.get_current_widget().command_generate_preview('asciidoc -a toc -b slidy2 -a data-uri -a icons')"), ("generate preview asciidoctor", "pp", 0.7, "self.get_current_widget().command_generate_preview('asciidoctor -a toc -a data-uri -a icons')"), ("generate preview deck.js", "pp slides", 0.7, "self.get_current_widget().command_generate_preview('asciidoc -a toc -b deckjs -a data-uri -a icons')"), ("generate pdf small", "", 0., """self.get_current_widget().command_generate_document('a2x --verbose -d article --icons --dblatex-opts "-T native -P doc.pdfcreator.show=0 -P doc.collab.show=0 -P latex.output.revhistory=0 -P doc.toc.show=1 -P table.title.top" -f pdf -D /tmp/adoc/ ')"""), ("generate pdf book", "", 0., """self.get_current_widget().command_generate_document('a2x --verbose -d book --icons --dblatex-opts "-T native -P doc.pdfcreator.show=0 -P doc.collab.show=0 -P latex.output.revhistory=0 -P doc.toc.show=1 -P table.title.top" -f pdf -D /tmp/adoc/ ')"""), ] super(AsciidocEditor, self).bw_add_command_list(command_list) self._editor_widget.bw_add_command_list(command_list) command_list += [ ("focus editor", "fe", 0.5, "import ctypes; _self = ctypes.cast(" + str(id(self)) + ", ctypes.py_object).value;" "_self._editor_widget.setFocus();"), ("focus preview", "fp", 0.5, "import ctypes; _self = ctypes.cast(" + str(id(self)) + ", ctypes.py_object).value;" "_self.webview.setFocus();"), ("increase font webview", "if if", 0.7, "import ctypes; _self = ctypes.cast(" + str(id(self)) + ", ctypes.py_object).value;" "_self.webview.setTextSizeMultiplier(_self.webview.textSizeMultiplier()+0.1);"), ("decrease font webview", "df df", 0.7, "import ctypes; _self = ctypes.cast(" + str(id(self)) + ", ctypes.py_object).value;" "_self.webview.setTextSizeMultiplier(_self.webview.textSizeMultiplier()-0.1);"), ] def copy2tmp(self): if not os.path.exists(TEMP_DIR): os.mkdir(TEMP_DIR) source = os.listdir(self.base_dir) destination = TEMP_DIR for files in source: shutil.move(files,destination) def command_generate_preview(self, adoc_command): self.command_save_file() #self.compile(backend + " -b deckjs -o " + self.get_html_output() + " " + TEMP_DIR + "pr.adoc") #asciidoc --verbose -a data-uri -a icons -a toc -a max-width=55em -o __builds/index.html /home/maiquel/Documents/qadoc/adoc/index.adoc #self.compile(adoc_command + " --attribute stylesheet=/home/maiquel/inet.prj/miow/widgets/adoc/mq_red.css -a data-uri -a icons -o " + self.get_html_output() + " " + TEMP_DIR + "pr.adoc") self.compile(adoc_command + ' -o ' +self.get_html_output() + ' ./"' + self.file_name + '"') if self.webview.url() != QUrl("file://" + self.get_html_output()): self.webview.load(QUrl(self.get_html_output())) def command_generate_document(self, adoc_command): self.command_save_file() self.compile(adoc_command + " " + TEMP_DIR + "pr.adoc") if self.webview.url() != QUrl("file://" + self.get_html_output()): self.webview.load(QUrl(self.get_html_output())) def compile(self, command): self.log(command) self.proc_compile.start(command) def bw_lock_command_window(self): return self._editor_widget.completer.popup().isVisible() def focusInEvent(self, focus_event): super(AsciidocEditor, self).focusInEvent(focus_event) self._editor_widget.setFocus() def get_html_output(self): return TEMP_DIR + "pr.html" def proc_compile_finished(self, result, exit_status): self.log("compilation finished") if self.webview.url().toString() == "": self.webview.load(QUrl(self.get_html_output())) else: self.webview.reload() def proc_compile_error(self, q_process_error): self.log("compilation error") print(q_process_error) def proc_compile_readyReadStandardOutput(self): result = self.proc_compile.readAllStandardOutput(); self.log(result) def proc_compile_readyReadStandardError(self): result = str(self.proc_compile.readAllStandardError()) self.log(result) def log(self, text): self.log_widget.appendPlainText(unicode(text))
class SimpleConnectWidget(QWidget): """ this widget displays a combobox with a list of instruments which the user can connect to, it also has a refresh button """ def __init__(self, parent=None): super(SimpleConnectWidget, self).__init__(parent) # main layout of the form is the verticallayout self.verticalLayout = QVBoxLayout() self.verticalLayout.setObjectName("verticalLayout") # moved the script stuff to a separate widget that lives in the toolbar self.labelLayout = QHBoxLayout() self.labelLayout.setObjectName("labelLayout") self.portLabel = QLabel(self) self.portLabel.setText("Availiable Ports") self.instrLabel = QLabel(self) self.instrLabel.setText("Instruments") self.labelLayout.addWidget(self.portLabel) self.labelLayout.addWidget(self.instrLabel) self.verticalLayout.addLayout(self.labelLayout) self.ports = QComboBox(self) self.ports.addItems(refresh_device_port_list()) self.ports.setObjectName("cbb_ports") self.instruments = QComboBox(self) self.instruments.addItems(utils.list_drivers(interface="real")[0]) self.ports.setObjectName("cbb_instrs") self.cbbLayout = QHBoxLayout() self.cbbLayout.setObjectName("cbbLayout") self.cbbLayout.addWidget(self.ports) self.cbbLayout.addWidget(self.instruments) self.verticalLayout.addLayout(self.cbbLayout) self.connectButton = QPushButton(self) self.connectButton.setText("Connect the instrument") self.connectButton.setObjectName("connectButton") self.refreshButton = QPushButton(self) self.refreshButton.setText("refresh the port list") self.refreshButton.setObjectName("refreshButton") self.verticalLayout.addWidget(self.connectButton) self.verticalLayout.addWidget(self.refreshButton) self.headerTextEdit = QPlainTextEdit("") fontsize = self.headerTextEdit.fontMetrics() pal = QPalette() textc = QColor(245, 245, 240) pal.setColor(QPalette.Base, textc) self.headerTextEdit.setPalette(pal) # d3d3be # self.headerTextEdit.ba self.headerTextEdit.setFixedHeight(fontsize.lineSpacing() * 8) self.verticalLayout.addWidget(self.headerTextEdit) # moved the start stop button to the toolbar only self.setLayout(self.verticalLayout) self.connect(self.connectButton, SIGNAL('clicked()'), self.on_connectButton_clicked) self.connect(self.refreshButton, SIGNAL('clicked()'), self.on_refreshButton_clicked) def on_connectButton_clicked(self): """Connect a given instrument through a given port""" port = self.ports.currentText() instrument_name = self.instruments.currentText() # load the module which contains the instrument's driver if __name__ == "__main__": class_inst = import_module(instrument_name) else: class_inst = import_module("." + instrument_name, package=utils.LABDRIVER_PACKAGE_NAME) msg = "" # msg.append("example") # msg.append("</span>") self.headerTextEdit.appendHtml(msg) # self.headerTextEdit.appendPlainText(msg) try: i = class_inst.Instrument(port) self.headerTextEdit.appendPlainText("%s" % (i.identify())) self.headerTextEdit.appendHtml( "The connection to the instrument %s through the port %s <span style=\" color:#009933;\" >WORKED</span>\n" % (instrument_name, port)) i.close() except: self.headerTextEdit.appendHtml( "The connection to the instrument %s through the port %s <span style=\" color:#ff0000;\" >FAILED</span>\n" % (instrument_name, port)) def on_refreshButton_clicked(self): """Refresh the list of the availiable ports""" self.ports.clear() self.ports.addItems(refresh_device_port_list())
class VNAWidget(QWidget): settings = None def __init__(self): super(VNAWidget, self).__init__() self.setWindowTitle("VNA Window") layout = QVBoxLayout(self) self.plot_layout = QHBoxLayout() layout.addLayout(self.plot_layout) self.mag_plot = PlotWidget() self.mag_plot.addLegend() self.plot_layout.addWidget(self.mag_plot) self.message_box = QPlainTextEdit() layout.addWidget(self.message_box) self.form_layout = QFormLayout() layout.addLayout(self.form_layout) self.dataset_edit = QLineEdit("TestSample") save_file_button = QPushButton("HDF5 File") self.save_file_edit = QLineEdit("C:\\_Data\\test.h5") # self.form_layout.addRow("VNA Address", self.address_combo_box) self.form_layout.addRow(save_file_button, self.save_file_edit) dataset_button = QPushButton("Dataset") self.form_layout.addRow(dataset_button, self.dataset_edit) self.button_layout = QHBoxLayout() layout.addLayout(self.button_layout) grab_trace_button = QPushButton("Grab Trace") save_button = QPushButton("Save") self.button_layout.addWidget(grab_trace_button) self.button_layout.addWidget(save_button) self.freqs = None self.mags = None self.phases = None self.vna = None self.current_vna_addr = None self.vna_params = None save_file_button.clicked.connect(self.change_save_file) dataset_button.clicked.connect(self.change_dataset) grab_trace_button.clicked.connect(self.grab_trace) save_button.clicked.connect(self.save_trace) def get_vna(self): return instruments['VNA'] def grab_trace(self): vna = self.get_vna() self.freqs = vna.do_get_xaxis() self.mags, self.phases = vna.do_get_data() self.replot() self.vna_params = vna.get_parameter_values(query=True) self.message("VNA Params") self.message("----------") for k, v in self.vna_params.items(): self.message(k, ":", v) self.message("") def replot(self): self.mag_plot.clear() self.mag_plot.plotItem.legend.setParent(None) self.mag_plot.addLegend() if self.freqs is None: return self.mag_plot.plot(self.freqs, self.mags, pen='g', name='Data') def message(self, *objs): self.message_box.appendPlainText(" ".join([str(o) for o in objs])) def change_save_file(self): filename = QFileDialog.getSaveFileName( self, "Save File", self.save_file_edit.text(), "HDF5 files (*.h5 *.hdf5)", options=QFileDialog.DontConfirmOverwrite ) self.save_file_edit.setText(filename) def change_dataset(self): dialog = QDialog() layout = QVBoxLayout(dialog) model = H5File(h5py.File(str(self.save_file_edit.text()))) tree_view = H5View() tree_view.setModel(model) tree_view.setSelectionMode(QAbstractItemView.SingleSelection) button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) button_box.accepted.connect(dialog.accept) button_box.rejected.connect(dialog.reject) layout.addWidget(tree_view) layout.addWidget(button_box) if dialog.exec_(): #self.dataset_edit.setText(tree_view.selected_path()[1:]) dsname = model.itemFromIndex(tree_view.selectedIndexes()[0]).fullname[1:] self.dataset_edit.setText(dsname) def get_h5group(self): filename = str(self.save_file_edit.text()) h5file = datasrv.get_file(filename) path = str(self.dataset_edit.text()) return h5helpers.resolve_path(h5file, path) def save_trace_csv(self): default_name = time.strftime("trace_%Y%m%d_%H%M%S.dat") save_path = str(self.save_path_edit.text()) default_filename = os.path.join(save_path, default_name) filename = str(QFileDialog.getSaveFileName(self, "Save Trace", default_filename)) data = numpy.array([self.freqs, self.mags, self.phases]).transpose() numpy.savetxt(filename, data) def save_trace(self): group = self.get_h5group() if 'freqs' in group: reply = QMessageBox.question(self, "", "Dataset exists in file, Overwrite?", QMessageBox.Yes | QMessageBox.No) if reply == QMessageBox.No: return group['freqs'] = self.freqs group['mags'] = self.mags group['phases'] = self.phases h5helpers.set_scale(group, 'freqs', 'mags') h5helpers.set_scale(group, 'freqs', 'phases') h5helpers.update_attrs(group, self.vna_params) self.message("Saved in file %s" % group.get_fullname())
def ShowWorking(self): getcontext().prec = 3 working = QPlainTextEdit() working.setWindowTitle("Kc calculation") reactants = [] products = [] for x in self._CurrentReaction.GetReactants(): if x.GetUsed(): reactants.append(x) for x in self._CurrentReaction.GetProducts(): if x.GetUsed(): products.append(x) working.appendPlainText("Concentration = moles / volume") volume = self._CurrentReaction.GetVolume() working.appendPlainText("Volume = "+str(volume)+" dm^3") pvalues = [] rvalues = [] for x in products: working.appendPlainText("Concentration of "+x.GetFormula()+" = "+str(Decimal(x.GetConcentration(volume)) + Decimal(0.0))+" mol dm^-3") pvalues.append(x.GetConcentration(volume)) pvalues.append(x.GetSRatio()) for x in reactants: working.appendPlainText("Concentration of "+x.GetFormula()+" = "+str(Decimal(x.GetConcentration(volume)) + Decimal(0.0))+" mol dm^-3") rvalues.append(x.GetConcentration(volume)) rvalues.append(x.GetSRatio()) kcvalue = "Value of Kc =" x = 0 while x < len(pvalues): kcvalue += " ("+str(Decimal(pvalues[x]) + Decimal(0.0))+")^" x += 1 kcvalue += str(pvalues[x]) x += 1 kcvalue += " /" x = 0 while x < len(rvalues): kcvalue += " ("+str(Decimal(rvalues[x]) + Decimal(0.0))+")^" x += 1 kcvalue += str(rvalues[x]) x += 1 working.appendPlainText(kcvalue) rproductsum = 0 for x in reactants: rproductsum += x.GetSRatio() pproductsum = 0 for x in products: pproductsum += x.GetSRatio() working.appendPlainText("There are "+str(len(reactants))+" reactants, with units mol dm^-3.") working.appendPlainText("The product of these units is mol^"+str(rproductsum)+" dm^"+str(rproductsum * -3)+".") working.appendPlainText("There are "+str(len(products))+" products, with units mol dm^-3.") working.appendPlainText("The product of these units is mol^"+str(pproductsum)+" dm^"+str(pproductsum * -3)+".") working.appendPlainText("The product units must be divided by the reactant units, so") working.appendPlainText(self._CurrentReaction.GetKc()) self._ExtraWindows.append(working) working.show()
class Ui_MainWindow(object): def setupUi(self, MainWindow): MainWindow.setObjectName(_fromUtf8("MainWindow")) MainWindow.resize(300, 270) self.centralwidget = QWidget(MainWindow) self.centralwidget.setObjectName(_fromUtf8("centralwidget")) self.buttonSave = QPushButton(self.centralwidget) self.buttonSave.setGeometry(QRect(120, 235, 71, 32)) self.buttonSave.setObjectName(_fromUtf8("buttonSave")) self.inputFolder = QLineEdit(self.centralwidget) self.inputFolder.setGeometry(QRect(130, 10, 131, 23)) self.inputFolder.setObjectName(_fromUtf8("inputFolder")) self.buttonSelectFolder = QToolButton(self.centralwidget) self.buttonSelectFolder.setGeometry(QRect(263, 10, 27, 23)) self.buttonSelectFolder.setToolButtonStyle(Qt.ToolButtonIconOnly) self.buttonSelectFolder.setAutoRaise(False) self.buttonSelectFolder.setArrowType(Qt.NoArrow) self.buttonSelectFolder.setObjectName(_fromUtf8("buttonSelectFolder")) self.labelFolder = QLabel(self.centralwidget) self.labelFolder.setGeometry(QRect(10, 13, 101, 16)) self.labelFolder.setObjectName(_fromUtf8("labelFolder")) self.inputLogin = QLineEdit(self.centralwidget) self.inputLogin.setGeometry(QRect(130, 40, 161, 23)) self.inputLogin.setObjectName(_fromUtf8("inputLogin")) self.inputPassword = QLineEdit(self.centralwidget) self.inputPassword.setGeometry(QRect(130, 70, 161, 23)) self.inputPassword.setObjectName(_fromUtf8("inputPassword")) self.labelLogin = QLabel(self.centralwidget) self.labelLogin.setGeometry(QRect(10, 42, 62, 16)) self.labelLogin.setObjectName(_fromUtf8("labelLogin")) self.labelPassword = QLabel(self.centralwidget) self.labelPassword.setGeometry(QRect(10, 72, 62, 16)) self.labelPassword.setObjectName(_fromUtf8("labelPassword")) self.output = QPlainTextEdit(self.centralwidget) self.output.setEnabled(True) self.output.setGeometry(QRect(10, 100, 281, 131)) self.output.viewport().setProperty("cursor", QCursor(Qt.IBeamCursor)) self.output.setReadOnly(True) self.output.setObjectName(_fromUtf8("output")) font = QApplication.font() font.setPointSize(11) self.output.setFont(font) MainWindow.setCentralWidget(self.centralwidget) self.retranslateUi(MainWindow) self.connectSignals() QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): MainWindow.setWindowTitle(QApplication.translate("MainWindow", "TDS Dropbox setup", None, QApplication.UnicodeUTF8)) self.buttonSave.setText(QApplication.translate("MainWindow", "Save", None, QApplication.UnicodeUTF8)) self.buttonSelectFolder.setText(QApplication.translate("MainWindow", "...", None, QApplication.UnicodeUTF8)) self.labelFolder.setText(QApplication.translate("MainWindow", "Folder to sync", None, QApplication.UnicodeUTF8)) self.labelLogin.setText(QApplication.translate("MainWindow", "Login", None, QApplication.UnicodeUTF8)) self.labelPassword.setText(QApplication.translate("MainWindow", "Password", None, QApplication.UnicodeUTF8)) def connectSignals(self): QObject.connect(self.buttonSelectFolder, SIGNAL("clicked()"), self.selectFolder) QObject.connect(self.centralwidget, SIGNAL("folderIsSet(PyQt_PyObject)"), self.setFolder) QObject.connect(self.buttonSave, SIGNAL("clicked()"), self.validateData) def selectFolder(self): folder = QFileDialog.getExistingDirectory(self.centralwidget, "Choose folder to sync", os.getenv("HOME")) QObject.emit(self.centralwidget, SIGNAL("folderIsSet(PyQt_PyObject)"), folder) def setFolder(self, folder): self.inputFolder.setText(folder) def validateData(self): validate = True if (len(self.inputFolder.text()) == 0): self.error("You haven't choose the dir to sync!") validate = False if (len(self.inputLogin.text()) == 0): self.error("You havent enter the login!") validate = False if (len(self.inputPassword.text()) == 0): self.error("You haven't enter the password!") validate = False if (validate): self.lockGui() self.out("setup start") self.setupSync({"folder": self.inputFolder.text(), "login": self.inputLogin.text(), "password": self.inputPassword.text()}) self.unlockGui() def lockGui(self): self.inputFolder.setReadOnly(True) self.inputLogin.setReadOnly(True) self.inputPassword.setReadOnly(True) self.buttonSave.setDisabled(True) self.buttonSelectFolder.setDisabled(True) def unlockGui(self): self.inputFolder.setReadOnly(False) self.inputLogin.setReadOnly(False) self.inputPassword.setReadOnly(False) self.buttonSave.setDisabled(False) self.buttonSelectFolder.setDisabled(False) def setupSync(self, data): p = Popen(["./letssync.sh", "-u%(login)s" % data, "-p%(password)s" % data, "%(folder)s" % data]) if (p.wait() != 0): self.error("an error occuring during setup!") else: self.out("setup complete!") def error(self, message): self.out("ERROR: {}".format(message)) def out(self, message): self.output.appendPlainText("{0} :: {1}".format(datetime.now().strftime("%H:%M"), message))
class BluetoothWindow(QMainWindow): def __init__(self, inbuf, outbuf,parent=None): super(BluetoothWindow, self).__init__(parent) self.sendbuf=outbuf self.receivebuf=inbuf self.output=QPlainTextEdit() self.output.setReadOnly(True) self.output.setLineWrapMode(QPlainTextEdit.WidgetWidth) self.hor = QHBoxLayout() self.ver = QVBoxLayout() def updateValue(key, value): pidvalues[key] = float(value) print key, "updated to", value for k, v in pidvalues.iteritems(): label = QLabel(k) edit = QLineEdit(str(v)) button = QPushButton("Update") l = QHBoxLayout() l.addWidget(label, 2) l.addWidget(edit, 5) l.addWidget(button, 2) self.ver.addLayout(l) button.clicked.connect(lambda clicked, label=label, edit=edit: updateValue(label.text(), edit.text())) self.hor.addWidget(self.output) self.hor.addLayout(self.ver) w = QWidget() w.setLayout(self.hor) self.setCentralWidget(w) SampleTimeInSec = (pidvalues["PID_SAMPLE_TIME"]) / 1000.0 for i in range(4): pid_params.append(pid_params_typedef()) pid_params[pidvalues["PID_THROTTLE"]].kp = pidvalues["KP_THROTTLE"]; pid_params[pidvalues["PID_THROTTLE"]].ki = pidvalues["KI_THROTTLE"] * SampleTimeInSec; pid_params[pidvalues["PID_THROTTLE"]].kd = pidvalues["KD_THROTTLE"] / SampleTimeInSec; pid_params[pidvalues["PID_THROTTLE"]].min = pidvalues["MIN_THROTTLE"]; pid_params[pidvalues["PID_THROTTLE"]].max = pidvalues["MAX_THROTTLE"]; pid_params[pidvalues["PID_PITCH"]].kp = pidvalues["KP_PITCH"]; pid_params[pidvalues["PID_PITCH"]].ki = pidvalues["KI_PITCH"] * SampleTimeInSec; pid_params[pidvalues["PID_PITCH"]].kd = pidvalues["KD_PITCH"] / SampleTimeInSec; pid_params[pidvalues["PID_PITCH"]].min = pidvalues["MIN_PITCH"]; pid_params[pidvalues["PID_PITCH"]].max = pidvalues["MAX_PITCH"]; pid_params[pidvalues["PID_ROLL"]].kp = pidvalues["KP_ROLL"]; pid_params[pidvalues["PID_ROLL"]].ki = pidvalues["KI_ROLL"] * SampleTimeInSec; pid_params[pidvalues["PID_ROLL"]].kd = pidvalues["KD_ROLL"] / SampleTimeInSec; pid_params[pidvalues["PID_ROLL"]].min = pidvalues["MIN_ROLL"]; pid_params[pidvalues["PID_ROLL"]].max = pidvalues["MAX_ROLL"]; pid_params[pidvalues["PID_YAW"]].kp = pidvalues["KP_YAW"]; pid_params[pidvalues["PID_YAW"]].ki = pidvalues["KI_YAW"] * SampleTimeInSec; pid_params[pidvalues["PID_YAW"]].kd = pidvalues["KD_YAW"] / SampleTimeInSec; pid_params[pidvalues["PID_YAW"]].min = pidvalues["MIN_YAW"]; pid_params[pidvalues["PID_YAW"]].max = pidvalues["MAX_YAW"]; for i in pid_params: print i def receiveText(self): # | 2-5 | Roll | [-pi, pi] | # | 6-9 | Pitch | [-pi, pi] | # | 10-13 | Yaw | [-pi, pi] | # | 14-17 | Height | [0, 10m] | # | 18-21 | Battery | [0, 100%] | rolldata="" pitchdata="" yawdata="" heightdata="" batterydata="" for i in range(4): rolldata+=self.receivebuf.pop(0) for i in range(4): pitchdata+=self.receivebuf.pop(0) for i in range(4): yawdata+=self.receivebuf.pop(0) for i in range(4): heightdata+=self.receivebuf.pop(0) for i in range(4): batterydata+=self.receivebuf.pop(0) roll=struct.unpack('f', rolldata) pitch=struct.unpack('f', pitchdata) yaw=struct.unpack('f', yawdata) self.output.appendPlainText("p "+str(pitch[0])+", r "+str(roll[0])+", y "+str(yaw[0])) ## pids data.pitch = pitch[0] data.roll = roll[0] data.yaw = yaw[0] global lastThrottle pid_output.throttle = self.pid_compute(pidvalues["PID_THROTTLE"], lastThrottle, command.throttle); pid_output.pitch = self.pid_compute(pidvalues["PID_PITCH"], data.pitch, command.pitch); pid_output.roll = self.pid_compute(pidvalues["PID_ROLL"], data.roll, command.roll); pid_output.yaw = self.pid_compute(pidvalues["PID_YAW"], data.yaw, command.yaw); #Save last throttle value lastThrottle = pid_output.throttle * 2 * ( pidvalues["MAX_THROTTLE"] / MOTOR_SPEED_MAX) - pidvalues["MIN_THROTTLE"]; #Add offset to throttle pid_output.throttle += MOTOR_SPEED_HALF; self.motors_pid_apply() ## update gui self.repaint() def motor_name(self, motor): if (motor == MOTOR_RIGHT_BACK): return "RIGHT__BACK" elif (motor == MOTOR_LEFT_BACK): return "LEFT___BACK" elif (motor == MOTOR_RIGHT_FRONT): return "RIGHT_FRONT" elif (motor == MOTOR_LEFT_FRONT): return "LEFT__FRONT" else: return "UNKNOWN" def motors_set_speed(self, motor, value): self.output.appendPlainText("motor "+str(self.motor_name(motor))+", value "+str(int(value))) def motors_pid_apply(self): self.motors_set_speed(MOTOR_RIGHT_FRONT, pid_output.throttle - pid_output.pitch - pid_output.roll - pid_output.yaw); self.motors_set_speed(MOTOR_LEFT_FRONT, pid_output.throttle - pid_output.pitch + pid_output.roll + pid_output.yaw); self.motors_set_speed(MOTOR_RIGHT_BACK, pid_output.throttle + pid_output.pitch - pid_output.roll + pid_output.yaw); self.motors_set_speed(MOTOR_LEFT_BACK, pid_output.throttle + pid_output.pitch + pid_output.roll - pid_output.yaw); def pid_compute(self, index, input, setpoint): pid = pid_params[index] retVal = 0 #Compute all the working error variables*/ error = setpoint - input; pid.iterm += pid.ki * error; if (pid.iterm > pid.max) : pid.iterm = pid.max; else: if (pid.iterm < pid.min): pid.iterm = pid.min; dInput = (input - pid.lastInput); #Compute PID Output*/ retVal = (pid.kp * error + pid.iterm - pid.kd * dInput); if (retVal > pid.max): retVal = pid.max; else: if (retVal < pid.min): retVal = pid.min; #Remember some variables for next time*/ pid.lastInput = input; pid_params[index] = pid return retVal def reset(self): self.output.clear()
class RestEditor(WithSingleIO, QWidget): """Restructredtext editor """ def __init__(self, params, parent=None): QWidget.__init__(self, parent) self.setMinimumWidth(300) self.setMinimumHeight(300) # create widgets self._editor_widget = mixin( WithFind, WithMqEditIO, WithBasicIdentationManager, WithLineHighlight, WithFixedFont, WithLineNumbers, WithViewPortMargins, WithWordCompletionMulty_, WithCompletion, QPlainTextEdit)(self) self.webview = QWebView(self) #self.webview.load(QUrl("/home/maiquel/develop/developing/main/qt/qadoc/bin/__builds/documents.html")) self.splitter = QSplitter(Qt.Horizontal) self.splitter.addWidget(self._editor_widget) self.splitter.addWidget(self.webview) self.splitter.setSizes([self.size().width(), self.size().width()]) self.splitterv = QSplitter(Qt.Vertical) self.splitterv.addWidget(self.splitter) self.log_widget = QPlainTextEdit() self.splitterv.addWidget(self.log_widget) layout = QVBoxLayout(self) layout.addWidget(self.splitterv) layout.setMargin(0) self.setLayout(layout) # proc_compile self.proc_compile = QProcess() self.proc_compile.finished.connect(self.proc_compile_finished) self.proc_compile.error.connect(self.proc_compile_error) self.proc_compile.readyReadStandardOutput.connect(self.proc_compile_readyReadStandardOutput) self.proc_compile.readyReadStandardError.connect(self.proc_compile_readyReadStandardError) WithSingleIO.__init__(self, params) def bw_add_command_list(self, command_list): command_list += [ ("generate preview restructuretext", "pp", 1.0, "self.get_current_widget().command_generate_preview('rst2html')"), ] super(RestEditor, self).bw_add_command_list(command_list) self._editor_widget.bw_add_command_list(command_list) command_list += [ ("focus editor", "fe", 0.5, "import ctypes; _self = ctypes.cast(" + str(id(self)) + ", ctypes.py_object).value;" "_self._editor_widget.setFocus();"), ("focus preview", "fp", 0.5, "import ctypes; _self = ctypes.cast(" + str(id(self)) + ", ctypes.py_object).value;" "_self.webview.setFocus();"), ] def command_generate_preview(self, backend): self.command_save_file() if not os.path.exists(TEMP_DIR): os.mkdir(TEMP_DIR) temp_source_file = open(TEMP_DIR + 'pr.rst','wt') temp_source_file.write(self._editor_widget.toPlainText()) temp_source_file.close() self.compile(backend + " --stylesheet=./widgets/rst2html.style " + TEMP_DIR + "pr.rst" + " " + self.get_html_output()) if self.webview.url() != QUrl("file://" + self.get_html_output()): self.webview.load(QUrl(self.get_html_output())) def compile(self, command): self.log(command) self.proc_compile.start(command) def bw_lock_command_window(self): return self._editor_widget.completer.popup().isVisible() def focusInEvent(self, focus_event): super(RestEditor, self).focusInEvent(focus_event) self._editor_widget.setFocus() def get_html_output(self): return TEMP_DIR + "pr.html" def proc_compile_finished(self, result, exit_status): self.log("compilation finished") if self.webview.url().toString() == "": self.webview.load(QUrl(self.get_html_output())) else: self.webview.reload() def proc_compile_error(self, q_process_error): self.log("compilation error") print(q_process_error) def proc_compile_readyReadStandardOutput(self): result = self.proc_compile.readAllStandardOutput(); self.log(result) def proc_compile_readyReadStandardError(self): result = str(self.proc_compile.readAllStandardError()) self.log(result) def log(self, text): self.log_widget.appendPlainText(text)
class BR_JobDock(QDockWidget): transcode_data = pyqtSignal([dict], [str]) job_complete = pyqtSignal() def __init__(self, job, passes, job_id, closesig, source, parent=None): name = source.title super().__init__(name, parent) self.job = job self.passes = passes self.job_id = job_id self.closesig = closesig self.source = source self.setWindowTitle(name) self.setFeatures(QDockWidget.DockWidgetMovable | QDockWidget.DockWidgetFloatable) self.setAllowedAreas(Qt.BottomDockWidgetArea) self.setFloating(True) self.widget = QWidget() layout = QVBoxLayout() # layout.setSizeConstraint(QVBoxLayout.SetFixedSize) message_layout = QFormLayout() self.lblPass = QLabel('Pass ? of {}'.format(passes)) message_layout.addRow(self.lblPass) self.lblFrame = QLabel('?') message_layout.addRow('Frame:', self.lblFrame) self.lblFps = QLabel('?') message_layout.addRow('Frames per Second:', self.lblFps) self.lblSize = QLabel('?') message_layout.addRow('File Size:', self.lblSize) self.lblTime = QLabel('?') message_layout.addRow('Video Time:', self.lblTime) self.lblBitrate = QLabel('?') message_layout.addRow('Bitrate:', self.lblBitrate) layout.addLayout(message_layout) self.progressbar = QProgressBar() self.progressbar.setRange(0, self.source.length.total_seconds()) layout.addWidget(self.progressbar) self.qualitybar = QualityBar() layout.addWidget(self.qualitybar) btn_layout = QHBoxLayout() btn_More = QPushButton('More') btn_More.setCheckable(True) btn_layout.addWidget(btn_More) btn_layout.addStretch() self.btnCancel = QPushButton('Close') self.btnCancel.setIcon(QIcon(QPixmap(':/icons/application-exit.png'))) self.btnCancel.clicked.connect(self.on_cancel_clicked) btn_layout.addWidget(self.btnCancel) layout.addLayout(btn_layout) self.terminal = QPlainTextEdit() self.terminal.setReadOnly(True) self.terminal.setShown(False) # self.terminal.setMinimumWidth(400) btn_More.toggled.connect(self.terminal.setVisible) layout.addWidget(self.terminal) griplayout = QHBoxLayout() griplayout.addWidget(QSizeGrip(self.widget)) griplayout.addStretch() griplayout.addWidget(QSizeGrip(self.widget)) layout.addLayout(griplayout) self.widget.setLayout(layout) self.setWidget(self.widget) self.transcode_data[dict].connect(self.on_avconv_data) self.transcode_data[str].connect(self.on_terminal_data) self.closesig.connect(parent.on_jobclose) def start(self, dir): self.runjob = TranscodeJob(self.job, self.passes, self.source, dir, self.transcode_data, self.job_complete) self.runjob.completesig.connect(self.on_job_complete) self.btnCancel.setText('Stop') self.runjob.start() @pyqtSlot(dict) def on_avconv_data(self, match): self.lblPass.setText('Pass {pass} of {passes}'.format(**match)) self.lblFrame.setText('{frame}'.format(**match)) self.lblFps.setText('{fps}'.format(**match)) size = round(int(match['size']) / 1024, 2) self.lblSize.setText('{} MB'.format(size)) time = DvdTimeDelta(seconds=float(match['time'])) self.lblTime.setText('{}'.format(time)) self.lblBitrate.setText('{bitrate} kbps'.format(**match)) self.qualitybar.setValue(int(round(float(match['q']) * 10))) self.progressbar.setValue(int(round(float(match['time'])))) @pyqtSlot(str) def on_terminal_data(self, text): self.terminal.appendPlainText(text) @pyqtSlot() def on_cancel_clicked(self): if self.runjob.is_alive(): msg = QMessageBox(QMessageBox.Question, 'Cancelling Job', 'Do you want to cancel the running job?') msg.setStandardButtons(QMessageBox.Yes | QMessageBox.No) msg.setDefaultButton(QMessageBox.No) ans = msg.exec_() if ans == QMessageBox.Yes: self.runjob.cancel() else: self.close_demand() @pyqtSlot() def on_job_complete(self): self.lblPass.setText('Completed') self.btnCancel.setText('Close') def close_demand(self): self.closesig.emit(self.job_id) self.close() def cancel(self): self.runjob.cancel() self.runjob.join()
class MainWindow(pMainWindow): def __init__(self, parentWidget=None): pMainWindow.__init__(self, parentWidget) self.createGui() def saveState(self): pMainWindow.saveState(self) self.settings().setValue( "MainWindow/Style", self.agStyles.currentStyle() ) evm = pEnvironmentVariablesManager() evm.setVariables( self.eveVariables.variables() ) evm.save() self.settings().setValue("UpdateChecker/Last Updated" , self.ucMkS.lastUpdated()) self.settings().setValue("UpdateChecker/Last Checked" , self.ucMkS.lastChecked()) def restoreState(self): pMainWindow.restoreState(self) self.agStyles.setCurrentStyle( self.settings().value( "MainWindow/Style" ).toString() ) variables = [] evm = pEnvironmentVariablesManager() evm.load() variables = evm.variables() evm.mergeNewVariables( variables ) self.eveVariables.setVariables( variables, True ) self.ucMkS.setLastUpdated( self.settings().value( "UpdateChecker/Last Updated" ).toDateTime() ) self.ucMkS.setLastChecked( self.settings().value( "UpdateChecker/Last Checked" ).toDateTime() ) def createGui(self): pNetworkAccessManager.instance().setCacheDirectory( qApp.applicationDirPath().append( "/tmp" ) ) self.twPages = QTabWidget( self ) self.setCentralWidget( self.twPages ) # initialize gui self.createMenuBar() self.createPlainTextEdit() self.createActionsTreeView() self.createConsole() self.createVersionsTests() self.createListEditors() self.createEnvironmentVariablesEditor() self.createCustomWidgets() self.createUpdateChecker() QTimer.singleShot( 3000, self.ucMkS.silentCheck ) # create fake dock widget for testing '''for ( i = 0; i < 10; i++ ) dw = QDockWidget( self ) dw.setObjectName( QString( "Dock%1" ).arg( i ) ) dw.toggleViewAction().setObjectName( QString( "DockViewAction%1" ).arg( i ) ) self.dockToolBar( Qt.LeftToolBarArea ).addDockWidget( dw, QString( "Dock %1" ).arg( i ), QIcon( scaledPixmap( ":/fresh/country-flags/ad.png", QSize( 96, 96 ) ) ) ) }''' # list dock widgets in the menu for dockWidget in self.findChildren(QDockWidget): #dockWidget.setAttribute( Qt.WA_DeleteOnClose ) action = dockWidget.toggleViewAction() self.mActionsModel.addAction( "mView/mDockWidgets/%s" % \ action.objectName() , action ) self.mActionsModel.setDefaultShortcut(action, QKeySequence( "Ctrl+%s" % chr( max( 32, qrand() % 127 ) ) ) ) def createMenuBar(self): # set menu bar model self.mActionsModel = pActionsModel( self ) self.menuBar().setModel( self.mActionsModel ) # create menus and sub menus self.mActionsModel.addMenu( "mFile", self.tr( "&File" ) ) self.mActionsModel.addMenu( "mEdit", self.tr( "&Edit" ) ) self.mActionsModel.addMenu( "mView", self.tr( "&View" ) ) self.mActionsModel.addMenu( "mView/mStyle", self.tr( "&Style" ) ) self.mActionsModel.addMenu( "mView/mMode", self.tr( "&Mode" ) ) self.mActionsModel.addMenu( "mView/mDockToolBarManager", self.tr( "&Dock ToolBar Manager" ) ) self.mActionsModel.addMenu( "mView/mDockWidgets", self.tr( "Dock &Widgets" ) ) # create actions aQuit = self.mActionsModel.addAction( "mFile/aQuit", self.tr( "&Quit" ) ) aClassic = self.mActionsModel.addAction( "mView/mMode/aShowClassic", self.tr( "Classic" ) ) aClassic.setCheckable( True ) aModern = self.mActionsModel.addAction( "mView/mMode/aShowModern", self.tr( "Modern" ) ) aModern.setCheckable( True ) # style actions self.agStyles = pStylesActionGroup( self ) self.agStyles.installInMenuBar( self.menuBar(), "mView/mStyle" ) # action group agDockToolBarManagerMode = QActionGroup( self ) agDockToolBarManagerMode.addAction( aClassic ) agDockToolBarManagerMode.addAction( aModern ) # add dock toolbar manager actions for dockToolBar in self.dockToolBarManager().dockToolBars(): action = dockToolBar.toggleViewAction() self.mActionsModel.addAction( "mView/mDockToolBarManager/%s" % action.objectName() , action ) action = dockToolBar.toggleExclusiveAction() self.mActionsModel.addAction( "mView/mDockToolBarManager/%s" % action.objectName(), action ) # connections aQuit.triggered.connect(self.close) self.agStyles.styleSelected.connect(self.setCurrentStyle) self.dockToolBarManager().modeChanged.connect( self.dockToolBarManagerModeChanged) aClassic.triggered.connect(self.dockToolBarManagerClassic) aModern.triggered.connect(self.dockToolBarManagerModern) def createPlainTextEdit(self): self.pteLog = QPlainTextEdit( self ) self.pteLog.setReadOnly( True ) self.pteLog.setTabStopWidth( 40 ) self.twPages.addTab( self.pteLog, self.tr( "Log" ) ) def createActionsTreeView(self): self.tvActions = QTreeView( self ) self.tvActions.setModel( self.menuBar().model() ) self.mActionsModel.addMenu( "mEdit/mActions", self.tr( "&Actions" ) ) aAddAction = self.mActionsModel.addAction( "mEdit/mActions/aAddAction", self.tr( "&Add action" ) ) aRemoveAction = self.mActionsModel.addAction( "mEdit/mActions/aRemoveAction", self.tr( "&Remove selected action" ) ) aEditTextNode = self.mActionsModel.addAction( "mEdit/mActions/aEditTextNode", self.tr( "&Edit selected node text" ) ) aEditShortcuts = self.mActionsModel.addAction( "mEdit/mActions/aEditShortcuts", self.tr( "Edit the actions &shortcuts" ) ) aAddAction.triggered.connect(self.aAddAction_triggered) aRemoveAction.triggered.connect(self.aRemoveAction_triggered) aEditTextNode.triggered.connect(self.aEditTextNode_triggered) aEditShortcuts.triggered.connect(self.aEditShortcuts_triggered) self.twPages.addTab( self.tvActions, self.tr( "Actions" ) ) def createConsole(self): cShell = pConsole( "Shell:/> ", self ) self.commands = ConsoleCommands( self, self ) cShell.addAvailableCommand( self.commands ) self.dwShell = pDockWidget( self ) self.dwShell.setObjectName( "Shell" ) self.dwShell.setWidget( cShell ) self.dwShell.toggleViewAction().setObjectName( "ShellViewAction" ) self.dockToolBar( Qt.BottomToolBarArea ).addDockWidget( self.dwShell, self.tr( "Shell" ), QIcon(pGuiUtils.scaledPixmap( ":/fresh/country-flags/ro.png", QSize( 96, 96 ) ) ) ) def createEnvironmentVariablesEditor(self): self.eveVariables = pEnvironmentVariablesEditor( self ) self.dwEnvironmentVariablesEditor = pDockWidget( self ) self.dwEnvironmentVariablesEditor.setObjectName( "EnvironmentVariablesEditor" ) self.dwEnvironmentVariablesEditor.setWidget( self.eveVariables ) self.dwEnvironmentVariablesEditor.toggleViewAction().setObjectName( "EnvironmentVariablesEditorViewAction" ) self.dockToolBar( Qt.TopToolBarArea ).addDockWidget( self.dwEnvironmentVariablesEditor, self.tr( "Environment Variables Editor" ), QIcon( pGuiUtils.scaledPixmap(":/fresh/country-flags/it.png", QSize( 96, 96 ) ) ) ) def createVersionsTests(self): v1 = pVersion ( "1.5.4" ) v2 = pVersion ( "1.5.4a" ) self.pteLog.appendPlainText( self.tr( "Testing versions %s & %s:\n" % (v1.toString(), v2.toString() ) )) # test 1 test1 = '' for op in [">", "<", ">=", "<=", "==", "!="]: test1 += '%s\t%s\t%s: %s\n' % \ (v1.toString(), op, v2.toString(), str(bool(eval("v1 %s v2" % op)))) # test 2 test2 = '' for op in [">", "<", ">=", "<=", "==", "!="]: test2 += '%s\t%s\t%s: %s\n' % \ (v1.toString(), op, v1.toString(), str(bool(eval("v1 %s v1" % op)))) self.pteLog.appendPlainText( self.tr( "Test 1:\n%s\n" % test1 )) self.pteLog.appendPlainText( self.tr( "Test 2:\n%s" % test2 )) def createListEditors(self): # list editor dock self.dwListEditor = pDockWidget( self ) twListEditors = QTabWidget( self.dwListEditor ) self.dwListEditor.setObjectName( "DockListEditor" ) self.dwListEditor.setWidget( twListEditors ) self.dwListEditor.toggleViewAction().setObjectName( "DockListEditorViewAction" ) self.dockToolBar( Qt.RightToolBarArea ).addDockWidget( self.dwListEditor, self.tr( "List Editor" ), QIcon(pGuiUtils.scaledPixmap( ":/fresh/country-flags/fr.png", QSize( 96, 96 )))) twListEditors.addTab( pStringListEditor( '', self ), self.tr( "Edit strings" ) ) twListEditors.addTab( pPathListEditor( '', ".", self ), self.tr( "Edit paths" ) ) twListEditors.addTab( pFileListEditor('', ".", "*.png", self ), self.tr( "Edit files" )) def createCustomWidgets(self): self.dwWidgets = pDockWidget( self ) self.dwWidgets.setObjectName( "dwWidgets" ) self.dwWidgets.toggleViewAction().setObjectName( "dwWidgetsViewAction" ) self.dockToolBar( Qt.LeftToolBarArea ).addDockWidget( self.dwWidgets, self.tr( "Custom Widgets" ), QIcon( pGuiUtils.scaledPixmap( ":/fresh/country-flags/es.png", QSize( 96, 96 ) ) ) ) self.dwWidgetsContents = QWidget( self ) self.dwWidgetsContentsLayout = QGridLayout( self.dwWidgetsContents ) self.dwWidgets.setWidget( self.dwWidgetsContents ) pbOpenFile = QPushButton( self.tr( "Get open file names" ), self ) self.dwWidgetsContentsLayout.addWidget( pbOpenFile, 0, 0 ) pbOpenFile.clicked.connect(self.openFileDialog) pbOpenDirectory = QPushButton( self.tr( "Get open directory name" ), self ) self.dwWidgetsContentsLayout.addWidget( pbOpenDirectory, 1, 0 ) pbOpenDirectory.clicked.connect(self.openDirectoryDialog) pbQueuedMessage = QPushButton( self.tr( "Add queued message" ) ) self.dwWidgetsContentsLayout.addWidget( pbQueuedMessage, 2, 0 ) pbQueuedMessage.clicked.connect(self.addQueuedMessage) stylesButton = pStylesToolButton( self.dwWidgetsContents ) stylesButton.setSizePolicy( pbQueuedMessage.sizePolicy() ) stylesButton.setCheckableActions( False ) self.dwWidgetsContentsLayout.addWidget( stylesButton, 3, 0 ) stylesButton.styleSelected.connect(self.agStyles.setCurrentStyle) tcbActions = pTreeComboBox( self ) tcbActions.setModel( self.mActionsModel ) self.dwWidgetsContentsLayout.addWidget( tcbActions, 4, 0 ) paypal = pPaypalButton( self ) paypal.setBusinessId( "5R924WYXJ6BAW" ) paypal.setItemName( "QWBFS Manager" ) paypal.setItemId( "QWBFS-DONATION" ) paypal.setCurrencyCode( "EUR" ) self.dwWidgetsContentsLayout.addWidget( paypal, 5, 0 ) toolButton1 = pToolButton( self.dwWidgetsContents ) toolButton1.setToolButtonStyle( Qt.ToolButtonTextBesideIcon ) toolButton1.setText( self.tr( "Bottom To Top" ) ) toolButton1.setIcon( pIconManager.icon( "pt.png") ) toolButton1.setDirection( QBoxLayout.BottomToTop ) self.dwWidgetsContentsLayout.addWidget( toolButton1, 0, 1, 6, 1 ) toolButton2 = pToolButton( self.dwWidgetsContents ) toolButton2.setToolButtonStyle( Qt.ToolButtonTextBesideIcon ) toolButton2.setText( self.tr( "Top To Bottom" ) ) toolButton2.setIcon( pIconManager.icon( "br.png" ) ) toolButton2.setDirection( QBoxLayout.TopToBottom ) self.dwWidgetsContentsLayout.addWidget( toolButton2, 0, 2, 6, 1 ) colorButton = pColorButton( self.dwWidgetsContents ) self.dwWidgetsContentsLayout.addWidget( colorButton, 6, 0 ) def createUpdateChecker(self): self.ucMkS = pUpdateChecker( self ) self.ucMkS.setDownloadsFeedUrl( QUrl("http:#code.google.com/feeds/p/monkeystudio/downloads/basic" )) self.ucMkS.setVersion( "1.6.0.0" ) self.ucMkS.setVersionString( "1.6.0.0" ) self.ucMkS.setVersionDiscoveryPattern( ".*mks_([0-9\\.]+).*" ) self.mActionsModel.addMenu( "mHelp", self.tr( "&Help" ) ) self.mActionsModel.addAction( "mHelp/aUpdateChecker", self.ucMkS.menuAction() ) def aAddAction_triggered(self): index = self.tvActions.selectionModel().selectedIndexes()[0] path = '' if index.isValid(): action = mActionsModel.action( index ); if action.menu(): path = mActionsModel.path(action).split('/')[:-2] else: path = mActionsModel.path() if path: path += '/' path = QInputDialog.getText( self, '', self.tr( "Enter the full path where to add " + "the action (/some/path/to/add/the/actionName):" ), QLineEdit.Normal, path ) if not "/" in path or path.replace("/", '').trim().isEmpty(): return action = QAction( self ) action.setText(path.split('/')[-1]) if not self.mActionsModel.addAction( path, action ) : del action QMessageBox.information( self, '', self.tr( "Can't add action to '%s' % path" )) def aRemoveAction_triggered(self): index = self.tvActions.selectionModel().selectedIndexes()[0] if index.isValid(): node = self.mActionsModel.indexToNode( index ) if not self.mActionsModel.removeAction( node.path() ): QMessageBox.information( self, '', self.tr( "Can't remove action '%s'" % node.path() ) ) def aEditTextNode_triggered(self): index = self.tvActions.selectionModel().selectedIndexes()[0] if index.isValid(): node = self.mActionsModel.indexToNode( index ) text = QInputDialog.getText( self, '', self.tr( "Enter the node text:" ), QLineEdit.Normal, node.text()) if text: node.setText( text ) def aEditShortcuts_triggered(self): dlg = pActionsShortcutEditor ( self.mActionsModel, self ) dlg.exec_() def dockToolBarManagerModeChanged(self, mode ): if mode == pDockToolBarManager.Classic: self.mActionsModel.action( "mView/mMode/aShowClassic" ).trigger() elif mode == pDockToolBarManager.Modern: self.mActionsModel.action( "mView/mMode/aShowModern" ).trigger() else: assert(0) def dockToolBarManagerClassic(self): self.dockToolBarManager().setMode( pDockToolBarManager.Classic ) def dockToolBarManagerModern(self): self.dockToolBarManager().setMode( pDockToolBarManager.Modern ) def addQueuedMessage(self): ok, message = QInputDialog.getText( self, self.tr( "Add a queued message" ), self.tr( "Enter the message to show:" ), QLineEdit.Normal, self.tr( "This is the default message" )) if ok and message: msg = pQueuedMessage() msg.message = message msg.buttons[ QDialogButtonBox.Ok ] = '' msg.buttons[ QDialogButtonBox.Yes ] = self.tr( "Show QMessageBox" ) msg.object = self msg.slot = "queuedMessageToolBarButtonClicked" queuedMessageToolBar().appendMessage( msg ) def queuedMessageToolBarButtonClicked(self, button, message ): if button == QDialogButtonBox.Yes: QMessageBox.information( self, '', message.message ) def setCurrentStyle(self, style ): QApplication.setStyle( style ) def openFileDialog(self): caption = '' dir = '' filter = '' enabledTextCodec = True enabledOpenReadOnly = True selectedFilter = '' options = 0 result = pFileDialog.getOpenFileNames(self, caption, dir, filter, enabledTextCodec, enabledOpenReadOnly, selectedFilter, options) self.pteLog.appendPlainText( '' ) if result.isEmpty(): self.pteLog.appendPlainText( self.tr( "You canceled the open file dialog" ) ) else: texts = [] texts.append(self.tr( "You accepted the open file dialog" )) for type in result.keys(): if type == pFileDialog.TextCodec: texts.append( self.tr( "TextCodec: %s" % result[ type ].toString() )) elif type == pFileDialog.OpenReadOnly: texts.append( self.tr( "OpenReadOnly: %s" % result[ type ].toString() )) elif type == pFileDialog.Directory: texts.append( self.tr( "Directory: %s" % result[ type ].toString() )) elif type == pFileDialog.FileName: texts.append( self.tr( "FileName: %s" % result[ type ].toString() )) elif type == pFileDialog.FileNames: texts.append( self.tr( "FileNames: %s" % ", ".join(result[ type ].toStringList()))) elif type == pFileDialog.SelectedFilter: texts.append( self.tr( "SelectedFilter: %s" % result[ type ].toString() )) self.pteLog.appendPlainText( '\n'.join(texts)) def openDirectoryDialog(self): caption = '' dir = '' filter = '' enabledTextCodec = True enabledOpenReadOnly = True selectedFilter = '' options = 0 result = pFileDialog.getExistingDirectory( self, caption, dir, enabledTextCodec, enabledOpenReadOnly, options | QFileDialog.ShowDirsOnly ) self.pteLog.appendPlainText( '' ) if not result: self.pteLog.appendPlainText( self.tr( "You canceled the open directory dialog" ) ) else: texts = [] texts.append(self.tr( "You accepted the open directory dialog" )) for type in result.keys(): if type == pFileDialog.TextCodec: texts.append( self.tr( "TextCodec: %s" % result[ type ].toString() )) elif type == pFileDialog.OpenReadOnly: texts.append( self.tr("OpenReadOnly: %s" % result[ type ].toString())) elif type == pFileDialog.Directory: texts.append( self.tr( "Directory: %s" % result[ type ].toString() )) elif type == pFileDialog.FileName: texts.append( self.tr( "FileName: %s" % result[ type ].toString() )) elif type == pFileDialog.FileNames: texts.append( self.tr( "FileNames: %s" % ", ".join(result[ type ].toStringList()))) elif type == pFileDialog.SelectedFilter: texts.append(self.tr( "SelectedFilter: %s" % result[ type ].toString() )) self.pteLog.appendPlainText( '\n'.join(texts))