def __init__(self, chunksize=512, rate=44100, channel=2, sample_size=8
,codec="audio/pcm", threshold=500, save_dir=None):
self.chunksize = chunksize
self.rate = rate
self.sample_size = sample_size
self.channel = channel
self.sampleWidth = 2
#
self.format = QAudioFormat()
self.format.setChannelCount(self.channel)
self.format.setSampleRate(self.rate)
self.format.setSampleSize(self.sample_size)
self.format.setCodec(codec)
self.format.setByteOrder(QAudioFormat.LittleEndian) # 1
self.format.setSampleType(QAudioFormat.UnSignedInt) # 2 这个应该就决定了录音的质量，不然会有很强的滋滋声音
#
self.block = b"" # bytes 类型
self.record_buffer = QBuffer()
self.play_buffer = QBuffer()
# 不能用QIODevice()，因为这是个c++的虚类(还没有python实体化？),
# 顺便也就不用所谓的QAudioBuffer类了
self.pos = 0
self.duration = 0
# self.threshold = threshold
self.save_dir = save_dir
self.save_path = "./sound/test.wav"
def handlePrint(self, data):
with renderLock:
self.document, copies = data
self.update()
if platform == "linux":
bmp = QImage(self.size[0], self.size[1], QImage.Format_Mono)
self.paintEvent(None, bmp)
buffer = QBuffer()
buffer.open(QBuffer.ReadWrite)
bmp.save(buffer, "BMP")
img = Image.open(io.BytesIO(buffer.data()))
img.save("/tmp/image.png")
for i in range(copies):
os.system("lpr /tmp/image.png")
elif platform == "win32":
pix = self.grab()
bmp = QImage(pix)
buffer = QBuffer()
buffer.open(QBuffer.ReadWrite)
bmp.save(buffer, "BMP")
img = Image.open(io.BytesIO(buffer.data()))
printerName = win32print.GetDefaultPrinter()
deviceContext = win32ui.CreateDC()
deviceContext.CreatePrinterDC(printerName)
deviceContext.StartDoc("Inventory Label")
for i in range(copies):
deviceContext.StartPage()
dib = ImageWin.Dib(img)
dib.draw(deviceContext.GetHandleOutput(),
(0, 0, self.size[0], self.size[1]))
deviceContext.EndPage()
deviceContext.EndDoc()
deviceContext.DeleteDC()
def perform_request(self,
endpoint,
read_callback,
data="",
method='GET',
capture_errors=True):
"""
Perform a HTTP request.
:param endpoint: the endpoint to call (i.e. "statistics")
:param read_callback: the callback to be called with result info when we have the data
:param data: optional POST data to be sent with the request
:param method: the HTTP verb (GET/POST/PUT/PATCH)
:param capture_errors: whether errors should be handled by this class (defaults to True)
"""
performed_requests[self.request_id] = [
endpoint, method, data, time(), -1
]
performed_requests_ids.append(self.request_id)
if len(performed_requests_ids) > 200:
del performed_requests[performed_requests_ids.pop(0)]
url = self.base_url + endpoint
if method == 'GET':
buf = QBuffer()
buf.setData(data)
buf.open(QIODevice.ReadOnly)
get_request = QNetworkRequest(QUrl(url))
self.reply = self.sendCustomRequest(get_request, "GET", buf)
buf.setParent(self.reply)
elif method == 'PATCH':
buf = QBuffer()
buf.setData(data)
buf.open(QIODevice.ReadOnly)
patch_request = QNetworkRequest(QUrl(url))
self.reply = self.sendCustomRequest(patch_request, "PATCH", buf)
buf.setParent(self.reply)
elif method == 'PUT':
request = QNetworkRequest(QUrl(url))
request.setHeader(QNetworkRequest.ContentTypeHeader,
"application/x-www-form-urlencoded")
self.reply = self.put(request, data)
elif method == 'DELETE':
buf = QBuffer()
buf.setData(data)
buf.open(QIODevice.ReadOnly)
delete_request = QNetworkRequest(QUrl(url))
self.reply = self.sendCustomRequest(delete_request, "DELETE", buf)
buf.setParent(self.reply)
elif method == 'POST':
request = QNetworkRequest(QUrl(url))
request.setHeader(QNetworkRequest.ContentTypeHeader,
"application/x-www-form-urlencoded")
self.reply = self.post(request, data)
if read_callback:
self.received_json.connect(read_callback)
self.finished.connect(
lambda reply: self.on_finished(reply, capture_errors))
def loadFromMemory(self):
""" This slot function is called in the second Dialog process, when the
user presses the "Load Image from Shared Memory" button. First, it
attaches the process to the shared memory segment created by the first
Dialog process. Then it locks the segment for exclusive access, copies
the image data from the segment into a QBuffer, and streams the QBuffer
into a QImage. Then it unlocks the shared memory segment, detaches
from it, and finally displays the QImage in the Dialog.
"""
if not self.sharedMemory.attach():
self.ui.label.setText(
"Unable to attach to shared memory segment.\nLoad an "
"image first.")
return
buf = QBuffer()
ins = QDataStream(buf)
image = QImage()
self.sharedMemory.lock()
buf.setData(self.sharedMemory.constData())
buf.open(QBuffer.ReadOnly)
ins >> image
self.sharedMemory.unlock()
self.sharedMemory.detach()
self.ui.label.setPixmap(QPixmap.fromImage(image))
def copy_image(self, image, path):
# TODO : fails if the directory does not exist
# (which indicates the transcode failed)
src = self.parent.target_source
if src.isGetPutSupported():
ba = QByteArray()
buf = QBuffer(ba)
image.save(buf, "JPG")
#buf.seek(0)
fo = io.BytesIO(ba.data())
print(path)
try:
src.putfo(path, fo)
except Exception as e:
print("Exception copying art:")
print("from: %s" % path)
print("to : %s" % fo)
print("%s" % e)
else:
print("copy not supported for album art")
def wn_init (self) :
JC_LOG .info ( self.tm_wai ('Initializing ...') )
self.wu_stage = JC_FX_STAGE
self.wu_root = CjFxVBox ()
self.wu_scene = CjFxScene ( self.wu_root, 650, 650 )
self.wu_stage .setTitle (GC_APP_NM)
self.wu_stage .setScene (self.wu_scene)
nu_svg_fn = gf_pj ( GC_MILO_PN, 'as', 'fx-180611-1413.svg' )
JC_LOG .info ( f'SVG file => { gf_to_mps (nu_svg_fn) }' )
nu_ba = QByteArray ()
nu_bf = QBuffer (nu_ba)
nu_bf .open (QIODevice.WriteOnly)
QPixmap (nu_svg_fn) .save ( nu_bf, 'PNG' )
self.wu_iv_svg = CjFxImageView ( CjFxImage ( jf_ba_2_jbais (nu_ba) ) )
self.wu_wv_license = CjFxWebView ()
self.wu_wv_license .getEngine () .loadContent ('''
<center>
<div>Icons made by <a href="https://www.flaticon.com/authors/pixel-perfect" title="Pixel perfect">Pixel perfect</a>
from <a href="https://www.flaticon.com/" title="Flaticon">www.flaticon.com</a> is licensed
by <a href="http://creativecommons.org/licenses/by/3.0/" title="Creative Commons BY 3.0" target="_blank">CC 3.0 BY</a></div>
</center>
''')
self.wu_root .setAlignment (CjFxPos.CENTER)
self.wu_root .setSpacing (10)
self.wu_root .getChildren () .addAll ( [ self.wu_iv_svg, self.wu_wv_license ] )
jy_gc ('''{ x_yi, x_stage ->
x_stage .with {
onShown = { gp_yn x_yi, 'wn_shown' }
onCloseRequest = { gp_yn x_yi, 'wn_quit' }
}
}''', self.cu_yi, self.wu_stage )
self.wu_stage .show ()
self .wn_move_center ()
def pmap_to_pil_img(pmap):
buffer = QBuffer()
buffer.open(QBuffer.ReadWrite)
img = QImage(pmap)
img.save(buffer, "PNG")
return Image.open(io.BytesIO(buffer.data()))
def render_to_bytes(self, res):
"""Renders the image into an object of type 'str'"""
qt_format = self.format # this may not be constant due to processEvents()
image = self.render(res)
q_buffer = QBuffer()
image.save(q_buffer, qt_format)
return q_buffer.buffer().data()
def set_region(self, region):
"""
Put the playback start position to `position`.
"""
# avoid segfault if changing region during playback
self.stop()
position, end = region
position = max(0, min(position, end)) # don't start before 0
end = min(self.params.nframes, end) # don't set end after days!
self.region = position, end
print('set_region -> {:,}-{:,}'.format(*self.region))
print('region times: {}-{} (duration={})'.format(*self.region_timedeltas()))
frame_to_read = end - position
wav = wave.open(self.wav_path)
wav.setpos(position)
# we need to reinit buffer since the region could be shorter than before
self.buffer = QBuffer()
self.buffer.writeData(wav.readframes(frame_to_read))
wav.close()
start_time = position / self.params.framerate
self.progressBar.setValue(start_time * 100 / self.duration)
self.status_bar.showMessage(str(timedelta(seconds=start_time))[:-3])
def _encodeSnapshot(self, snapshot):
Major = 0
Minor = 0
try:
Major = int(CuraVersion.split(".")[0])
Minor = int(CuraVersion.split(".")[1])
except:
pass
if Major < 5:
from PyQt5.QtCore import QByteArray, QIODevice, QBuffer
else:
from PyQt6.QtCore import QByteArray, QIODevice, QBuffer
Logger.log("d", "Encoding thumbnail image...")
try:
thumbnail_buffer = QBuffer()
if Major < 5:
thumbnail_buffer.open(QBuffer.ReadWrite)
else:
thumbnail_buffer.open(QBuffer.OpenModeFlag.ReadWrite)
thumbnail_image = snapshot
thumbnail_image.save(thumbnail_buffer, "JPG")
base64_bytes = base64.b64encode(thumbnail_buffer.data())
base64_message = base64_bytes.decode('ascii')
thumbnail_buffer.close()
return base64_message
except Exception:
Logger.logException("w", "Failed to encode snapshot image")
def pickle(self):
"""
Pickle the image into a list containing important information.
Returns:
(list): containing
(str): "Image"
(float): X position of image.
(float): Y position of image.
(str): a string containing image data in base64 encoding.
(float): scale of the image.
(bool): true if the image contains a red border,
false otherwise.
"""
if self.data is None:
ba = QByteArray()
buffer = QBuffer(ba)
buffer.open(QIODevice.WriteOnly)
self.qImage.save(buffer, "PNG")
pickle = [
"Image",
self.x(),
self.y(),
str(ba.toBase64().data()),
self.scale(),
self.border,
]
else:
pickle = [
"Image",
self.x(),
self.y(), self.data,
self.scale(), self.border
]
return pickle
def _addIcon(self):
filter_ = self.tr("Images (*.jpg *.jpeg *.bmp *.png *.tiff *.gif);;"
"All files (*.*)")
fileName, _selectedFilter = QFileDialog.getOpenFileName(self,
self.tr("Open File"), self.latestDir,
filter_)
if fileName:
file_info = QFileInfo(fileName)
self.latestDir = file_info.absolutePath()
image = QImage()
if image.load(fileName):
maxWidth = 22
maxHeight = 15
if image.width() > maxWidth or image.height() > maxHeight:
scaledImage = image.scaled(maxWidth, maxHeight,
Qt.KeepAspectRatio, Qt.SmoothTransformation)
else:
scaledImage = image
ba = QByteArray()
buffer = QBuffer(ba)
buffer.open(QIODevice.WriteOnly)
scaledImage.save(buffer, 'png')
model = self.model()
index = model.index(self.selectedIndex().row(), model.fieldIndex('icon'))
model.setData(index, ba)
def ocrForImage(self, image):
"""
为截取的图片进行ocr识别
:param image: QImage
:return: null
"""
# Note:子线程里不能对ui界面做改动，ui界面修改只能在主线程中修改，下面注释的做法是错误的
# self.ui.ocrInfo.setText('识别中......')
byte = QByteArray()
buffer = QBuffer(byte)
buffer.open(QIODevice.WriteOnly)
image.save(buffer, 'PNG')
if self.ocrType == ocrType.ocr_general:
self.result = self.OCR.client.general_detect(
CIBuffers([byte.data()]))
elif self.ocrType == ocrType.ocr_handwriting:
self.result = self.OCR.client.handwriting_detect(
CIBuffers([byte.data()]))
elif self.ocrType == ocrType.ocr_idcard:
self.result = self.OCR.client.idcard_detect(
CIBuffers([byte.data()]), 0)
elif self.ocrType == ocrType.ocr_namecard:
self.result = self.OCR.client.namecard_detect(
CIBuffers([byte.data()]), 0)
elif self.ocrType == ocrType.ocr_bankcard:
self.result = self.OCR.client.bankcard_detect(
CIBuffers([byte.data()]))
else:
pass
self.processFinished.emit(self.result)
def eps(self, filename, rect=None, resolution=72.0, paperColor=None):
"""Create a EPS (Encapsulated Postscript) file for the selected rect or the whole page.
This needs the popplerqt5 module.
The filename may be a string or a QIODevice object. The rectangle is
relative to our top-left position. Normally vector graphics are
rendered, but in cases where that is not possible, the resolution will
be used to determine the DPI for the generated rendering.
"""
buf = QBuffer()
buf.open(QBuffer.WriteOnly)
success = self.pdf(buf, rect, resolution, paperColor)
buf.close()
if success:
from . import poppler
for pdf in poppler.PopplerPage.load(buf.data()):
ps = pdf.document.psConverter()
ps.setPageList([pdf.pageNumber + 1])
if isinstance(filename, str):
ps.setOutputFileName(filename)
else:
ps.setOutputDevice(filename)
try:
ps.setPSOptions(ps.PSOption(ps.Printing
| ps.StrictMargins))
ps.setPSOptions(
ps.PSOption(ps.Printing | ps.StrictMargins
| ps.PrintToEPS))
except AttributeError:
pass
ps.setVDPI(resolution)
ps.setHDPI(resolution)
return ps.convert()
return False
def pydoc(self, job, url):
from pygments.formatters import HtmlFormatter
from pygments.lexers.python import Python3Lexer
from pygments import highlight
modname = url.path().lstrip("/")
query = QUrlQuery(url)
extras = {}
if query.hasQueryItem("hl_lines"):
start, end = query.queryItemValue("hl_lines").split("-")
extras["hl_lines"] = list(range(int(start), int(end) + 1))
mod = importlib.import_module(modname)
filepath = inspect.getsourcefile(mod)
formatter = HtmlFormatter(title="Module %s" % modname,
full=True,
lineanchors="line",
**extras)
with open(filepath) as f:
code = highlight(f.read(), Python3Lexer(), formatter)
buffer = QBuffer(self)
buffer.setData(code.encode("utf-8"))
job.reply(b"text/html", buffer)
def saveBookInfo(self):
selected_items = self.treeFileList.selectedItems()
if len(selected_items) == 1:
QApplication.setOverrideCursor(Qt.BusyCursor)
item = selected_items[0]
meta = EbookMeta(item.text(2))
meta.get()
if self.book_cover:
data = QByteArray()
buf = QBuffer(data)
self.book_cover.save(buf, 'JPG')
meta.coverdata = bytes(buf.buffer())
if not meta.coverpage:
meta.coverpage = 'cover.jpg'
meta.coverpage_href = '{http://www.w3.org/1999/xlink}href'
else:
meta.coverpage = ''
meta.coverdata = None
meta.set_authors(self.editAuthor.text())
meta.book_title = self.editTitle.text()
meta.set_series(self.editSeries.text(), self.editSeriesNumber.text())
meta.lang = self.editBookLanguage.text()
meta.write()
item.setText(0, meta.book_title)
item.setText(1, meta.get_autors())
QApplication.restoreOverrideCursor()
elif len(selected_items) > 1:
msg = QMessageBox(self)
msg.setIcon(QMessageBox.Question)
msg.setWindowTitle(_translate('fb2mobi', 'Save'))
msg.setText(_translate('fb2mobi', 'Save changes in selected files?'))
msg.setStandardButtons(QMessageBox.Save | QMessageBox.Cancel)
if msg.exec_() == QMessageBox.Save:
QApplication.setOverrideCursor(Qt.BusyCursor)
for item in selected_items:
meta = EbookMeta(item.text(2))
meta.get()
(series, series_number) = meta.get_first_series()
authors = meta.get_autors()
if self.editAuthor.text():
authors = self.editAuthor.text()
if self.editSeries.text():
series = self.editSeries.text()
meta.set_authors(authors)
meta.set_series(series, series_number)
if self.editBookLanguage.text():
meta.lang = self.editBookLanguage.text()
meta.write()
item.setText(0, meta.book_title)
item.setText(1, meta.get_autors())
QApplication.restoreOverrideCursor()
def _image_to_byte_array(self, image) -> QByteArray:
byte_array = QByteArray()
buffer = QBuffer(byte_array)
buffer.open(QIODevice.WriteOnly)
image.save(buffer, 'png')
buffer.close()
return byte_array
def add_request(self, request):
if len(self.requests_in_flight) > self.max_in_flight:
self.evict_timed_out_requests()
self.requests_in_flight[id(request)] = request
log = [request, 0]
performed_requests.append(log)
# qt_request is managed by QNetworkAccessManager, so we don't have to
qt_request = QNetworkRequest(QUrl(request.url))
qt_request.setPriority(request.priority)
qt_request.setHeader(QNetworkRequest.ContentTypeHeader,
"application/x-www-form-urlencoded")
qt_request.setRawHeader(b'X-Api-Key', self.key)
buf = QBuffer()
if request.raw_data:
buf.setData(request.raw_data)
buf.open(QIODevice.ReadOnly)
request.reply = self.sendCustomRequest(qt_request,
request.method.encode("utf8"),
buf)
buf.setParent(request.reply)
connect(request.reply.finished, lambda: request.on_finished(request))
def get_frame_with_color_info(color: QColor, size=SIZE, rounded=True, as_bytes=False) -> Union[QImage, bytes]:
image = QImage(size, size, QImage.Format_ARGB32)
image.fill(Qt.transparent)
painter = QPainter(image)
painter.setRenderHint(QPainter.HighQualityAntialiasing)
painter.setPen(Qt.NoPen)
painter.setBrush(color)
if rounded:
painter.drawRoundedRect(0, 0, image.width(), image.height(), RADIUS, RADIUS, Qt.RelativeSize)
else:
painter.drawRect(0, 0, image.width(), image.height())
draw_hex(painter, size, color)
draw_rgb(painter, size, color)
painter.end()
if as_bytes:
ba = QByteArray()
buff = QBuffer(ba)
buff.open(QIODevice.WriteOnly)
image.save(buff, "PNG")
return ba.data()
return image
def cadProduto(self):
INSERI = CrudProduto()
INSERI.id = self.tx_idProduto.text()
INSERI.produto = self.tx_DescricaoProduto.text().upper()
if self.lb_FotoProduto.pixmap():
imagem = QPixmap(self.lb_FotoProduto.pixmap())
data = QByteArray()
buf = QBuffer(data)
imagem.save(buf, 'PNG')
INSERI.imagem = str(data.toBase64()).encode('utf8')[2:-1]
else:
INSERI.imagem = False
INSERI.categoria = self.cb_CategoriaProduto.currentData()
INSERI.marca = self.cb_MarcaProduto.currentData()
INSERI.estoqueMinimo = self.tx_EstoqueMinimoProduto.text()
INSERI.estoqueMaximo = self.tx_EstoqueMaximoProduto.text()
INSERI.obsProduto = self.tx_ObsProduto.text()
INSERI.valorCompra = self.tx_ValorCompraProduto.text().replace(",", ".")
INSERI.valorUnitario = self.tx_ValorUnitarioProduto.text().replace(",", ".")
INSERI.valorAtacado = self.tx_ValorAtacadoProduto.text().replace(",", ".")
INSERI.qtdeAtacado = self.tx_MinimoAtacado.text()
INSERI.inseriProduto()
self.janelaProdutos()
def __cssLinkClass(self, icon, size=32):
"""
Private method to generate a link class with an icon.
@param icon icon to be included (QIcon)
@param size size of the icon to be generated (integer)
@return CSS class string (string)
"""
cssString = \
"""a.{{0}} {{{{\n"""\
""" padding-left: {0}px;\n"""\
""" background: transparent url(data:image/png;base64,{1})"""\
""" no-repeat center left;\n"""\
""" font-weight: bold;\n"""\
"""}}}}\n"""
pixmap = icon.pixmap(size, size)
imageBuffer = QBuffer()
imageBuffer.open(QIODevice.ReadWrite)
if not pixmap.save(imageBuffer, "PNG"):
# write a blank pixmap on error
pixmap = QPixmap(size, size)
pixmap.fill(Qt.transparent)
imageBuffer.buffer().clear()
pixmap.save(imageBuffer, "PNG")
return cssString.format(
size + 4, str(imageBuffer.buffer().toBase64(), encoding="ascii"))
def encode_image(self, size: QSize = None, *, fmt="PNG") -> bytes:
""" Render to a bitmap image and convert it to a data stream. """
im = self.draw_image(size)
buf = QBuffer()
buf.open(QIODevice.WriteOnly)
im.save(buf, fmt)
return buf.data()
def pyqiodev(self):
"""Fixture providing a PyQIODevice with a QByteArray to test."""
data = QByteArray()
f = QBuffer(data)
qiodev = qtutils.PyQIODevice(f)
yield qiodev
qiodev.close()
def CadEmpresa(self):
INSERI = CrudEmpresa()
INSERI.id = self.tx_idEmpresa.text()
INSERI.nomeFantasia = self.tx_NomeFantasia.text().upper()
INSERI.razaoSocial = self.tx_RazaoSocial.text().upper()
INSERI.cnpj = self.tx_Cnpj.text()
INSERI.inscEstadual = self.tx_IE.text()
INSERI.telefone = re.sub(
'[^[0-9]', '', (self.tx_TelefoneEmpresa.text()))
INSERI.email = self.tx_EmailEmpresa.text()
INSERI.site = self.tx_SiteEmpresa.text()
INSERI.obs = self.tx_ObsEmpresa.text().upper()
INSERI.cep = re.sub('[^[0-9]', '', (self.tx_CepEmpresa.text()))
INSERI.endereco = self.tx_Endereco.text().upper()
INSERI.numero = self.tx_NumEmpresa.text()
INSERI.bairro = self.tx_BairroEmpresa.text().upper()
INSERI.cidade = self.tx_CidadeEmpresa.text().upper()
INSERI.estado = self.tx_EstadoEmpresa.text().upper()
INSERI.titulo = self.tx_Titulo.text()
INSERI.subtitulo = self.tx_SubTitulo.text()
if self.lb_LogoEmpresa.pixmap():
image = QPixmap(self.lb_LogoEmpresa.pixmap())
data = QByteArray()
buf = QBuffer(data)
image.save(buf, 'PNG')
logo = str(data.toBase64()).encode('utf8')[2:-1]
INSERI.logo = logo
else:
INSERI.logo = False
INSERI.inseriEmpresa()
self.lb_NomeFantasia.setText(self.tx_Titulo.text())
self.lb_NomeFantasia2.setText(INSERI.subtitulo)
self.setWindowTitle(INSERI.titulo + " " + INSERI.subtitulo)
def mouseMoveEvent(self, event):
""" If the mouse moves far enough when the left mouse button is held
down, start a drag and drop operation.
"""
if not event.buttons() & Qt.LeftButton:
return
if (event.pos() - self.dragStartPosition).manhattanLength() \
< QApplication.startDragDistance():
return
if not self.hasImage:
return
drag = QDrag(self)
mimeData = QMimeData()
output = QByteArray()
outputBuffer = QBuffer(output)
outputBuffer.open(QIODevice.WriteOnly)
self.imageLabel.pixmap().toImage().save(outputBuffer, 'PNG')
outputBuffer.close()
mimeData.setData('image/png', output)
drag.setMimeData(mimeData)
drag.setPixmap(self.imageLabel.pixmap().scaled(64, 64, Qt.KeepAspectRatio))
drag.setHotSpot(QPoint(drag.pixmap().width() / 2,
drag.pixmap().height()))
drag.start()
def picklePixmap(pixmap):
image = pixmap.toImage()
byt_arr = QByteArray()
buffer = QBuffer(byt_arr)
buffer.open(QIODevice.WriteOnly);
image.save(buffer, "PNG");
return byt_arr
def __init__(self, wav_path):
QMainWindow.__init__(self)
self.resize(350, 250)
self.setWindowTitle('MainWindow')
self._setLayout()
self.status_bar = self.statusBar()
self.wav_path = wav_path
self.params = utils.read_wav_info(wav_path)
self.duration = self.params.nframes / self.params.framerate
self.output = utils.get_audio_output(self.params)
self.output.stateChanged.connect(self.state_checkpoint)
self.output.setNotifyInterval(20)
self.output.notify.connect(self.notified)
self.loop_button.clicked.connect(self.switch_loop)
self.play_button.clicked.connect(self.play_pause)
self.random_button.clicked.connect(self.set_random_region)
self.export_button.clicked.connect(self.export_region)
self.command_edit.returnPressed.connect(self.command_entered)
self.loop_enabled = False
self.buffer = QBuffer()
self.region = None
self.set_region((0, REG_SECONDS * self.params.framerate))
def mimeData(self, indexes):
"""
Public method to return the mime data.
@param indexes list of indexes (QModelIndexList)
@return mime data (QMimeData)
"""
from .XbelWriter import XbelWriter
data = QByteArray()
stream = QDataStream(data, QIODevice.WriteOnly)
urls = []
for index in indexes:
if index.column() != 0 or not index.isValid():
continue
encodedData = QByteArray()
buffer = QBuffer(encodedData)
buffer.open(QIODevice.ReadWrite)
writer = XbelWriter()
parentNode = self.node(index)
writer.write(buffer, parentNode)
stream << encodedData
urls.append(index.data(self.UrlRole))
mdata = QMimeData()
mdata.setData(self.MIMETYPE, data)
mdata.setUrls(urls)
return mdata
def save(self):
"""
Public method to save the zoom values.
"""
if not self.__loaded:
return
from WebBrowser.WebBrowserWindow import WebBrowserWindow
if not WebBrowserWindow.isPrivate() and bool(self.__iconDatabasePath):
db = {}
for url, icon in self.__iconsDB.items():
ba = QByteArray()
buffer = QBuffer(ba)
buffer.open(QIODevice.WriteOnly)
icon.pixmap(32).toImage().save(buffer, "PNG")
db[url] = bytes(buffer.data()).decode(self.__encoding)
filename = os.path.join(self.__iconDatabasePath,
self.__iconsFileName)
try:
f = open(filename, "w")
json.dump(db, f)
f.close()
except (IOError, OSError):
# ignore silentyl
pass
def dropMimeData(self, data, action, row, column, parent):
"""
Public method to accept the mime data of a drop action.
@param data reference to the mime data (QMimeData)
@param action drop action requested (Qt.DropAction)
@param row row number (integer)
@param column column number (integer)
@param parent index of the parent node (QModelIndex)
@return flag indicating successful acceptance of the data (boolean)
"""
if action == Qt.IgnoreAction:
return True
if column > 0:
return False
parentNode = self.node(parent)
if not data.hasFormat(self.MIMETYPE):
if not data.hasUrls():
return False
from .BookmarkNode import BookmarkNode
node = BookmarkNode(BookmarkNode.Bookmark, parentNode)
node.url = bytes(data.urls()[0].toEncoded()).decode()
if data.hasText():
node.title = data.text()
else:
node.title = node.url
self.__bookmarksManager.addBookmark(parentNode, node, row)
return True
ba = data.data(self.MIMETYPE)
stream = QDataStream(ba, QIODevice.ReadOnly)
if stream.atEnd():
return False
undoStack = self.__bookmarksManager.undoRedoStack()
undoStack.beginMacro("Move Bookmarks")
from .XbelReader import XbelReader
while not stream.atEnd():
encodedData = QByteArray()
stream >> encodedData
buffer = QBuffer(encodedData)
buffer.open(QIODevice.ReadOnly)
reader = XbelReader()
rootNode = reader.read(buffer)
for bookmarkNode in rootNode.children():
rootNode.remove(bookmarkNode)
row = max(0, row)
self.__bookmarksManager.addBookmark(parentNode, bookmarkNode,
row)
self.__endMacro = True
return True
