def paint(self, painter, option, index):
option = QStyleOptionViewItem(option) # copy option
self.initStyleOption(option, index)
style = option.widget.style() if option.widget else QApplication.style()
doc = QTextDocument()
doc.setHtml(option.text)
# painting item without text
option.text = ""
style.drawControl(QStyle.CE_ItemViewItem, option, painter)
ctx = QAbstractTextDocumentLayout.PaintContext()
# Hilight text if item is selected
if option.state & QStyle.State_Selected:
ctx.palette.setColor(QPalette.Text, option.palette.color(QPalette.Active, QPalette.HighlightedText))
textRect = style.subElementRect(QStyle.SE_ItemViewItemText, option)
painter.save()
painter.translate(textRect.topLeft())
painter.setClipRect(textRect.translated(-textRect.topLeft()))
doc.documentLayout().draw(painter, ctx)
painter.restore()
def paint(self, painter, option, index):
options = QStyleOptionViewItem(option)
item = index.data(Qt.UserRole)
if isinstance(item, (CommentItem, ChangeItem)):
options.decorationAlignment = Qt.AlignHCenter
self.initStyleOption(options,index)
if options.widget is None:
style = QApplication.style()
else:
style = options.widget.style()
doc = QTextDocument()
doc.setHtml(options.text)
options.text = ""
style.drawControl(QStyle.CE_ItemViewItem, options, painter)
ctx = QAbstractTextDocumentLayout.PaintContext()
# Highlighting text if item is selected
#if (optionV4.state & QStyle::State_Selected)
#ctx.palette.setColor(QPalette::Text, optionV4.palette.color(QPalette::Active, QPalette::HighlightedText))
textRect = style.subElementRect(QStyle.SE_ItemViewItemText, options)
painter.save()
painter.translate(textRect.topLeft())
painter.setClipRect(textRect.translated(-textRect.topLeft()))
doc.documentLayout().draw(painter, ctx)
painter.restore()
def textDocument(self, title, htmltext): td = QTextDocument() td.setMetaInformation(QTextDocument.DocumentTitle, title) if self.ss: td.setDefaultStyleSheet(self.ss) td.setHtml(htmltext) td.setDefaultFont(globalSettings.font) return td
def __init__(self, page, *args, **kwargs):
self.page = page
super(TextViewer, self).__init__(*args, **kwargs)
self._document = QTextDocument(self)
self._document.setUseDesignMetrics(True)
self._page_number = 0
self.__offset_top = 0
class DocumentWriter(AbsObserver):
def __init__(self) -> None:
self.document = QTextDocument()
def update(self, value):
message = "\n".join(reversed(value))
self.document.setPlainText(message)
def initUI(self):
self.documento = QTextDocument()
# =================== WIDGETS QPUSHBUTTON ==================
buttonBuscar = QPushButton("Buscar usuarios", self)
buttonBuscar.setFixedSize(426, 26)
buttonBuscar.move(20, 20)
buttonLimpiar = QPushButton("Limpiar tabla", self)
buttonLimpiar.setFixedSize(140, 26)
buttonLimpiar.move(452, 20)
# =================== WIDGET QTREEWIDGET ===================
self.treeWidgetUsuarios = QTreeWidget(self)
self.treeWidgetUsuarios.setFont(
QFont(self.treeWidgetUsuarios.font().family(), 10, False))
self.treeWidgetUsuarios.setRootIsDecorated(False)
self.treeWidgetUsuarios.setHeaderLabels(
("D.N.I", "NOMBRE", "APELLIDO", "CORREO"))
self.model = self.treeWidgetUsuarios.model()
for indice, ancho in enumerate((110, 150, 150, 160), start=0):
self.model.setHeaderData(indice, Qt.Horizontal, Qt.AlignCenter,
Qt.TextAlignmentRole)
self.treeWidgetUsuarios.setColumnWidth(indice, ancho)
self.treeWidgetUsuarios.setAlternatingRowColors(True)
self.treeWidgetUsuarios.setFixedSize(572, 300)
self.treeWidgetUsuarios.move(20, 56)
# =================== WIDGETS QPUSHBUTTON ==================
buttonVistaPrevia = QPushButton("Vista previa", self)
buttonVistaPrevia.setFixedSize(140, 26)
buttonVistaPrevia.move(156, 364)
buttonImprimir = QPushButton("Imprimir", self)
buttonImprimir.setFixedSize(140, 26)
buttonImprimir.move(304, 364)
buttonExportarPDF = QPushButton("Exportar a PDF", self)
buttonExportarPDF.setFixedSize(140, 26)
buttonExportarPDF.move(452, 364)
# =================== EVENTOS QPUSHBUTTON ==================
buttonBuscar.clicked.connect(self.Buscar)
buttonLimpiar.clicked.connect(self.limpiarTabla)
buttonVistaPrevia.clicked.connect(self.vistaPrevia)
buttonImprimir.clicked.connect(self.Imprimir)
buttonExportarPDF.clicked.connect(self.exportarPDF)
def setDefaultFont(self):
"""Set the default font initially and based on an output font change.
"""
self.defaultFont = QTextDocument().defaultFont()
fontName = globalref.miscOptions['OutputFont']
if fontName:
self.defaultFont.fromString(fontName)
if self.useDefaultFont:
self.mainFont = self.defaultFont
def htmlToPlainText(text):
RICH_PREFIX = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" '\
'"http://www.w3.org/TR/REC-html40/strict.dtd">'
if text.startswith(RICH_PREFIX):
document = QTextDocument()
document.setHtml(text)
text = document.toPlainText()
return text
def textDocument(self): td = QTextDocument() td.setMetaInformation(QTextDocument.DocumentTitle, self.getDocumentTitle()) if self.ss: td.setDefaultStyleSheet(self.ss) td.setHtml(self.getHtml()) if self.font: td.setDefaultFont(self.font) return td
def mousePressEvent(self, QMouseEvent):
try:
doc = QTextDocument()
doc.setHtml(self.number_label.text())
self.number_clicked_signal.emit(doc.toPlainText())
except AttributeError:
pass
finally:
QMouseEvent.accept()
def searchtext(self):
#QTextDocument.FindFlags() cursorForward
#QTextDocument.FindBackward()
flag = QTextDocument.FindFlags() #反向搜索
searchtextexpress= self.lineEdit_searchexpression.text()
if searchtextexpress is not "":
print(searchtextexpress)
print(self.textBrowser_testcommand.cursor())
self.textBrowser_testcommand.find(searchtextexpress,QTextDocument.FindFlag())
print(self.textBrowser_testcommand.cursor())
def sizeHint(self, option, index):
self.initStyleOption(option, index)
doc = QTextDocument()
if index.column() == HistoryTableModel.columns_types.index('pubkey'):
doc.setHtml(option.text)
else:
doc.setPlainText("")
doc.setTextWidth(-1)
return QSize(doc.idealWidth(), doc.size().height())
def paint(self, painter, option, index):
self.initStyleOption(option, index)
foreground = index.data(Qt.ForegroundRole)
font = index.data(Qt.FontRole)
style = QApplication.style()
doc = QTextDocument()
if index.column() == HistoryTableModel.columns_types.index('pubkey'):
doc.setHtml(option.text)
else:
doc.setPlainText(option.text)
option.text = ""
style.drawControl(QStyle.CE_ItemViewItem, option, painter)
ctx = QAbstractTextDocumentLayout.PaintContext()
if foreground:
if foreground.isValid():
ctx.palette.setColor(QPalette.Text, foreground)
if font:
doc.setDefaultFont(font)
text_rect = style.subElementRect(QStyle.SE_ItemViewItemText, option)
painter.save()
painter.translate(text_rect.topLeft())
painter.setClipRect(text_rect.translated(-text_rect.topLeft()))
doc.documentLayout().draw(painter, ctx)
painter.restore()
def pixmap(cursor, num_lines=6, scale=0.8):
"""Return a QPixmap displaying the selected lines of the document.
If the cursor has no selection, num_lines are drawn.
By default the text is drawn 0.8 * the normal font size. You can change
that by supplying the scale parameter.
"""
block = cursor.document().findBlock(cursor.selectionStart())
c2 = QTextCursor(block)
if cursor.hasSelection():
c2.setPosition(cursor.selectionEnd(), QTextCursor.KeepAnchor)
c2.movePosition(QTextCursor.EndOfBlock, QTextCursor.KeepAnchor)
else:
c2.movePosition(QTextCursor.NextBlock, QTextCursor.KeepAnchor,
num_lines)
data = textformats.formatData('editor')
doc = QTextDocument()
font = QFont(data.font)
font.setPointSizeF(font.pointSizeF() * scale)
doc.setDefaultFont(font)
doc.setPlainText(c2.selection().toPlainText())
if metainfo.info(cursor.document()).highlighting:
highlighter.highlight(doc, state=tokeniter.state(block))
size = doc.size().toSize() + QSize(8, -4)
pix = QPixmap(size)
pix.fill(data.baseColors['background'])
doc.drawContents(QPainter(pix))
return pix
class SuggestionsDelegate(QStyledItemDelegate):
def __init__(self, parent=None):
super().__init__(parent=parent)
self._doc = QTextDocument()
self._translation_char_format = QTextCharFormat()
self._strokes_char_format = QTextCharFormat()
self._strokes_char_format.font().setStyleHint(QFont.Monospace)
@property
def text_font(self):
return self._translation_char_format.font()
@text_font.setter
def text_font(self, font):
self._translation_char_format.setFont(font)
@property
def strokes_font(self):
return self._strokes_char_format.font()
@strokes_font.setter
def strokes_font(self, font):
self._strokes_char_format.setFont(font)
def _format_suggestion(self, index):
suggestion = index.data(Qt.DisplayRole)
self._doc.clear()
cursor = QTextCursor(self._doc)
cursor.setCharFormat(self._translation_char_format)
cursor.insertText(escape_translation(suggestion.text) + ':')
if not suggestion.steno_list:
cursor.insertText(' ' + NO_SUGGESTIONS_STRING)
return
for strokes_list in suggestion.steno_list[:MAX_SUGGESTIONS_COUNT]:
cursor.insertBlock()
cursor.setCharFormat(self._strokes_char_format)
cursor.insertText(' ' + '/'.join(strokes_list))
def paint(self, painter, option, index):
painter.save()
if option.state & QStyle.State_Selected:
painter.fillRect(option.rect, option.palette.highlight())
text_color = option.palette.highlightedText()
else:
text_color = option.palette.text()
self._translation_char_format.setForeground(text_color)
self._strokes_char_format.setForeground(text_color)
painter.translate(option.rect.topLeft())
self._format_suggestion(index)
self._doc.drawContents(painter)
painter.restore()
def sizeHint(self, option, index):
self._format_suggestion(index)
return self._doc.size().toSize()
def sizeHint(self, option, index):
self.initStyleOption(option, index)
doc = QTextDocument()
if index.column() in (NetworkTableModel.columns_types.index('address'),
NetworkTableModel.columns_types.index('port')):
doc.setHtml(option.text)
else:
doc.setPlainText("")
doc.setTextWidth(option.rect.width())
return QSize(doc.idealWidth(), doc.size().height())
def _copy_results_current(self, grid):
"""Copy cell results for the current cell"""
current = grid.current
data = grid.model.code_array[current]
if data is None:
return
clipboard = QApplication.clipboard()
# Get renderer for current cell
renderer = grid.model.code_array.cell_attributes[current]["renderer"]
if renderer == "text":
clipboard.setText(repr(data))
elif renderer == "image":
if isinstance(data, BasicQImage):
clipboard.setImage(data)
else:
# We may have an svg image here
try:
svg_bytes = bytes(data)
except TypeError:
svg_bytes = bytes(data, encoding='utf-8')
if is_svg(svg_bytes):
mime_data = QMimeData()
mime_data.setData("image/svg+xml", svg_bytes)
clipboard.setMimeData(mime_data)
elif renderer == "markup":
mime_data = QMimeData()
mime_data.setHtml(str(data))
# Also copy data as plain text
doc = QTextDocument()
doc.setHtml(str(data))
mime_data.setText(doc.toPlainText())
clipboard.setMimeData(mime_data)
elif renderer == "matplotlib" and isinstance(data,
matplotlib_figure.Figure):
# We copy and svg to the clipboard
svg_filelike = io.BytesIO()
png_filelike = io.BytesIO()
data.savefig(svg_filelike, format="svg")
data.savefig(png_filelike, format="png")
svg_bytes = (svg_filelike.getvalue())
png_image = QImage().fromData(png_filelike.getvalue())
mime_data = QMimeData()
mime_data.setData("image/svg+xml", svg_bytes)
mime_data.setImageData(png_image)
clipboard.setMimeData(mime_data)
def textDocument(self, title, htmltext): td = QTextDocument() td.setMetaInformation(QTextDocument.DocumentTitle, title) if self.ss: td.setDefaultStyleSheet(self.ss) td.setHtml(htmltext) td.setDefaultFont(globalSettings.font) return td
def textDocument(self): td = QTextDocument() td.setMetaInformation(QTextDocument.DocumentTitle, self.getDocumentTitle()) if self.ss: td.setDefaultStyleSheet(self.ss) td.setHtml(self.getHtml()) td.setDefaultFont(globalSettings.font) return td
def add_defaults(self):
"""Add default table entries."""
if not self.get_race_property(self.NAME):
self.set_race_property(self.NAME, defaults.RACE_NAME)
if not self.get_race_property(self.DATE):
self.set_date(QDateTime.currentDateTime().date())
if not self.get_race_property(self.NOTES):
document = QTextDocument()
document.setDocumentLayout(QPlainTextDocumentLayout(document))
self.set_notes(document)
def __init__(self,
connection: Connection,
base: Path,
*args,
obj=None,
**kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
self.setupUi(self)
self.connection = connection
self.base_path = base
self.base_path.mkdir(parents=True, exist_ok=True)
self.last_start = None
self.status = None
self.cost = None
self.using_db = None
self.current_page = -1
self.results = []
self.tasks = []
self.tables: Dict[str, Set[str]] = {}
self.tree_file.setModel(QStandardItemModel())
self.update_tree_file()
self.timer = QTimer(self)
self.timer.setInterval(100)
self.timer.timeout.connect(self.update_cost)
self.mutex = QMutex()
self.wait_condition = QWaitCondition()
self.queue = Queue(1)
self.worker = Worker(connection, self.mutex, self.wait_condition,
self.queue)
self.worker.executed.connect(self.worker_execute)
self.worker.finished.connect(self.worker_finish)
self.worker.start()
self.document = QTextDocument(self)
self.processing_highlight = False
self.document.setDefaultStyleSheet(SQLHighlighter.style())
self.text_code.setDocument(self.document)
self.text_code.setFocus()
self.set_status(Status.Waiting)
self.set_result_report()
self.change_page()
self.update_buttons()
self.change_db(None)
self.page_changed.connect(self.change_page)
self.page_changed.connect(self.show_result)
self.page_changed.connect(self.update_buttons)
self.sql_finished.connect(self.update_tree_file)
def save_consent(self):
formats = "Text (*.txt)"
filename, extension = QFileDialog.getSaveFileName(
self, 'Save File', path_str(Path('~').expanduser() / 'my_consent.txt'), formats)
if filename != '':
with open(filename, 'w', encoding='utf8') as file:
consent_txt = (self.ui.welcomelabel.text() +
self.ui.consentbox.text() +
self.ui.reblabel.text())
doc = QTextDocument()
doc.setHtml(consent_txt)
consent_plaintext = doc.toPlainText()
file.write(consent_plaintext)
def sizeHint(self, option, index):
"""QStyledItemDelegate.sizeHint implementation
"""
options = QStyleOptionViewItem(option)
self.initStyleOption(options, index)
doc = QTextDocument()
if self._font is not None:
doc.setDefaultFont(self._font)
doc.setDocumentMargin(1)
# bad long (multiline) strings processing doc.setTextWidth(options.rect.width())
doc.setHtml(options.text)
return QSize(doc.idealWidth(), doc.size().height())
class Task(object):
font = QFont('Decorative', 10)
labelW, labelH = 20, 20
pen = QPen(Qt.black, 0.5, Qt.DashLine)
dotSize = 18
def __init__(self, tid, taskInfo, drawingInputs):
self.tid = tid
#
self.plabel, self.dlabel = QTextDocument(), QTextDocument()
self.plabel.setHtml("%d<sup>+</sup>" % self.tid)
self.dlabel.setHtml("%d<sup>-</sup>" % self.tid)
self.plabel.setDefaultFont(Task.font)
self.dlabel.setDefaultFont(Task.font)
#
pLocXY, dLocXY, pTW_Xs, dTW_Xs, self.coX4GC, self.oriY_GC, self.yUnit = drawingInputs
self.ppX, self.ppY = pLocXY
self.dpX, self.dpY = dLocXY
self.pTW_rect = self.get_twRect(pTW_Xs, isPickupTW=True)
self.dTW_rect = self.get_twRect(dTW_Xs, isPickupTW=False)
def get_twRect(self, tw, isPickupTW=False):
a, b = tw
return QRectF(
a, self.oriY_GC if isPickupTW else self.oriY_GC + self.yUnit,
b - a, self.yUnit)
def draw(self, qp):
for cx, cy, label in [(self.ppX, self.ppY, self.plabel),
(self.dpX, self.dpY, self.dlabel)]:
drawLabel(qp, label, cx, cy, Task.labelW, Task.labelH)
qp.setPen(Task.pen)
qp.setBrush(Qt.NoBrush)
for f, (p0, p1) in [(qp.drawEllipse, (self.ppX, self.ppY)),
(qp.drawRect, (self.dpX, self.dpY))]:
f(p0 - Task.dotSize / 2, p1 - Task.dotSize / 2, Task.dotSize,
Task.dotSize)
#
pen = QPen(Qt.black, 1, Qt.SolidLine)
qp.setPen(pen)
qp.setBrush(Qt.NoBrush)
for cx, cy, label in [
(self.coX4GC - hMargin * 2.0, vMargin * 3 + self.oriY_GC,
self.plabel),
(self.coX4GC - hMargin * 2.0,
vMargin * 3 + self.oriY_GC + self.yUnit, self.dlabel)
]:
drawLabel(qp, label, cx, cy, Task.labelW, Task.labelH)
qp.drawRect(self.pTW_rect)
qp.drawRect(self.dTW_rect)
def initUI(self):
#----------------------Widgets-----------------------------
#Objeto document
self.document=QTextDocument()
#Qpusbutton
button_data=QPushButton("Mostrar datos", self)
button1=QPushButton("Vista Previa", self)
button2=QPushButton("Imprimir", self)
button3=QPushButton("Exportar", self)
button4=QPushButton("Limpiar", self)
#-------Objeto: QTreWidget-------------------
self.table_user=QTreeWidget()
self.table_user.setHeaderLabels(("Id_Usuario", "Mes", "Nombre", "Estatus", "Fecha de alta"))
#Formato
self.model=self.table_user.model()
for indice, ancho in enumerate((110, 150, 150, 160), start=0):
self.model.setHeaderData(indice, Qt.Horizontal, Qt.AlignCenter, Qt.TextAlignmentRole)
self.table_user.setColumnWidth(indice, ancho)
self.table_user.setAlternatingRowColors(True)
#----------Objeto Layout vertical para QPushButton--------
horizontal_layout=QHBoxLayout()
horizontal_layout.addWidget(button_data)
horizontal_layout.addWidget(button1)
horizontal_layout.addWidget(button2)
horizontal_layout.addWidget(button3)
horizontal_layout.addWidget(button4)
horizontal_layout.addStretch()
#---------Objeto - Layout-----------------
gridLayout1=QGridLayout()
#Agregar al gridlayout1
gridLayout1.addLayout(horizontal_layout, 0, 1, 1, 1)
gridLayout1.addWidget(self.table_user, 1, 1, 1, 1)#widget
#Asignar al layout clase widget
self.setLayout(gridLayout1)
#--------------Eventos qpushbutton----------------------------------------
button_data.clicked.connect(self.data) #data
button1.clicked.connect(self.view) #var_view previa
button2.clicked.connect(self.print_document) #imprimir
button3.clicked.connect(self.pdf_export) #exportar
button4.clicked.connect(self.clear) #limpiar
def __init__(self, post):
super(RSSArticleItem, self).__init__()
self.post_id = post.id
self.post_link = post.link
date = ""
try:
date = "[%d-%02d-%02d]" % (post.published_parsed.tm_year,
post.published_parsed.tm_mon,
post.published_parsed.tm_mday)
except Exception:
pass
layout = QVBoxLayout()
layout.setSpacing(0)
layout.setContentsMargins(10, 10, 0, 0)
post_info_widget = QWidget()
post_box = QHBoxLayout()
post_box.setSpacing(10)
post_box.setContentsMargins(0, 0, 0, 0)
date_label = QLabel(date)
date_label.setFont(QFont('Arial', 18))
post_box.addWidget(date_label)
title_label = QLabel(post.title)
title_label.setFont(QFont('Arial', 18))
post_box.addWidget(title_label)
author_label = QLabel("(" + post.author + ")")
author_label.setFont(QFont('Arial', 16))
post_box.addWidget(author_label)
post_box.addStretch(1)
post_info_widget.setLayout(post_box)
description_doc = QTextDocument()
description_doc.setHtml(post.description)
description_label = QLabel(
self.truncate_description(description_doc.toPlainText()))
description_label.setWordWrap(True)
description_label.setStyleSheet("color: #333")
description_label.setFont(QFont("Arial", 16))
layout.addWidget(post_info_widget)
layout.addWidget(description_label)
self.setLayout(layout)
def _get_textdoc(self, index):
"""Create the QTextDocument of an item.
Args:
index: The QModelIndex of the item to draw.
"""
# FIXME we probably should do eliding here. See
# qcommonstyle.cpp:viewItemDrawText
# https://github.com/qutebrowser/qutebrowser/issues/118
text_option = QTextOption()
if self._opt.features & QStyleOptionViewItem.WrapText:
text_option.setWrapMode(QTextOption.WordWrap)
else:
text_option.setWrapMode(QTextOption.ManualWrap)
text_option.setTextDirection(self._opt.direction)
text_option.setAlignment(QStyle.visualAlignment(
self._opt.direction, self._opt.displayAlignment))
if self._doc is not None:
self._doc.deleteLater()
self._doc = QTextDocument(self)
self._doc.setDefaultFont(self._opt.font)
self._doc.setDefaultTextOption(text_option)
self._doc.setDocumentMargin(2)
stylesheet = """
.highlight {
color: {{ conf.colors.completion.match.fg }};
}
"""
with jinja.environment.no_autoescape():
template = jinja.environment.from_string(stylesheet)
self._doc.setDefaultStyleSheet(template.render(conf=config.val))
if index.parent().isValid():
view = self.parent()
pattern = view.pattern
columns_to_filter = index.model().columns_to_filter(index)
if index.column() in columns_to_filter and pattern:
repl = r'<span class="highlight">\g<0></span>'
text = re.sub(re.escape(pattern).replace(r'\ ', r'|'),
repl, self._opt.text, flags=re.IGNORECASE)
self._doc.setHtml(text)
else:
self._doc.setPlainText(self._opt.text)
else:
self._doc.setHtml(
'<span style="font: {};">{}</span>'.format(
html.escape(config.val.fonts.completion.category),
html.escape(self._opt.text)))
def printReciept(self, htmltext):
dialog = QPrintDialog(self.printer, self)
if dialog.exec_():
document = QTextDocument()
# print(self.printer.logicalDpiX())
# print(self.printer.logicalDpiX() * (210 / 25.4))
# print(self.printer.logicalDpiY())
# print(self.printer.logicalDpiY() * (297 / 25.4))
#A4
# document.setPageSize(QSizeF(self.printer.logicalDpiX() * (210 / 25.4),self.printer.logicalDpiY() * (297 / 25.4)));
#小票
qsizeF = QSizeF(self.printer.logicalDpiX() * (257 / 25.4),
self.printer.logicalDpiY() * (125 / 25.4))
# qsizeF = QSizeF(self.printer.logicalDpiX() * (215.90 / 25.4), self.printer.logicalDpiY() * (127.00 / 25.4));
# qsizeF = QSizeF(self.printer.logicalDpiY() * (125 / 25.4),self.printer.logicalDpiX() * (257 / 25.4));
self.printer.setPageSize(QPrinter.Custom)
self.printer.setPaperName("小票2")
paperSize = QSizeF(257, 125)
self.printer.setPaperSize(paperSize, QPrinter.Millimeter)
# self.printer.setPageSizeMM(qsizeF)
document.setPageSize(qsizeF)
# font = QFont();
# font.setPointSize(6)
# document.setDefaultFont(font);
document.setHtml(htmltext)
document.print_(self.printer)
def drawContents(self, painter):
"""
Reimplementation of drawContents to limit the drawing
inside `textRext`.
"""
painter.setPen(self.__color)
painter.setFont(self.font())
if self.__textRect:
rect = self.__textRect
else:
rect = self.rect().adjusted(5, 5, -5, -5)
if Qt.mightBeRichText(self.__message):
doc = QTextDocument()
doc.setHtml(self.__message)
doc.setTextWidth(rect.width())
cursor = QTextCursor(doc)
cursor.select(QTextCursor.Document)
fmt = QTextBlockFormat()
fmt.setAlignment(self.__alignment)
cursor.mergeBlockFormat(fmt)
painter.save()
painter.translate(rect.topLeft())
doc.drawContents(painter)
painter.restore()
else:
painter.drawText(rect, self.__alignment, self.__message)
def __init__(self, tid, taskInfo, drawingInputs):
self.tid = tid
#
self.plabel, self.dlabel = QTextDocument(), QTextDocument()
self.plabel.setHtml("%d<sup>+</sup>" % self.tid)
self.dlabel.setHtml("%d<sup>-</sup>" % self.tid)
self.plabel.setDefaultFont(Task.font)
self.dlabel.setDefaultFont(Task.font)
#
pLocXY, dLocXY, pTW_Xs, dTW_Xs, self.coX4GC, self.oriY_GC, self.yUnit = drawingInputs
self.ppX, self.ppY = pLocXY
self.dpX, self.dpY = dLocXY
self.pTW_rect = self.get_twRect(pTW_Xs, isPickupTW=True)
self.dTW_rect = self.get_twRect(dTW_Xs, isPickupTW=False)
def pixmap(cursor, num_lines=6, scale=0.8):
"""Return a QPixmap displaying the selected lines of the document.
If the cursor has no selection, num_lines are drawn.
By default the text is drawn 0.8 * the normal font size. You can change
that by supplying the scale parameter.
"""
block = cursor.document().findBlock(cursor.selectionStart())
c2 = QTextCursor(block)
if cursor.hasSelection():
c2.setPosition(cursor.selectionEnd(), QTextCursor.KeepAnchor)
c2.movePosition(QTextCursor.EndOfBlock, QTextCursor.KeepAnchor)
else:
c2.movePosition(QTextCursor.NextBlock, QTextCursor.KeepAnchor, num_lines)
data = textformats.formatData('editor')
doc = QTextDocument()
font = QFont(data.font)
font.setPointSizeF(font.pointSizeF() * scale)
doc.setDefaultFont(font)
doc.setPlainText(c2.selection().toPlainText())
if metainfo.info(cursor.document()).highlighting:
highlighter.highlight(doc, state=tokeniter.state(block))
size = doc.size().toSize() + QSize(8, -4)
pix = QPixmap(size)
pix.fill(data.baseColors['background'])
doc.drawContents(QPainter(pix))
return pix
def paint(self, painter, option, index):
self.initStyleOption(option, index)
style = QApplication.style()
doc = QTextDocument()
if index.column() in (NetworkTableModel.columns_types.index('address'),
NetworkTableModel.columns_types.index('port'),
NetworkTableModel.columns_types.index('api')):
doc.setHtml(option.text)
else:
doc.setPlainText(option.text)
option.text = ""
style.drawControl(QStyle.CE_ItemViewItem, option, painter)
ctx = QAbstractTextDocumentLayout.PaintContext()
text_rect = style.subElementRect(QStyle.SE_ItemViewItemText, option)
painter.save()
painter.translate(text_rect.topLeft())
painter.setClipRect(text_rect.translated(-text_rect.topLeft()))
doc.documentLayout().draw(painter, ctx)
painter.restore()
def sizeHint(self, option, index):
self.initStyleOption(option, index)
doc = QTextDocument()
doc.setHtml(option.text)
doc.setTextWidth(option.rect.width())
return QSize(doc.idealWidth(), max(doc.size().height(), option.decorationSize.height()))
def open_file(self):
"""Loads a file into the PlainTextEdit Qwidget"""
file_name, j = QFileDialog.getOpenFileName(self, 'Select Text file',
'/home')
if file_name.endswith('rtxt'):
file = pickle.load(open(file_name, 'rb'))
self.new_doc = QTextDocument()
self.new_doc.setHtml(file)
self.plainTextEdit.setDocument(self.new_doc)
elif file_name is None: # happens when use cancels dialog
self.display_message('No file', 'No file selected')
else:
self.display_message(
'Error', 'Wrong format selected . please Choose txt files')
def color_json(obj):
doc = QTextDocument()
doc.setDefaultStyleSheet(open('stylesheet/json_style.css').read())
if isinstance(obj, str):
doc.setHtml(string_to_html(obj))
else:
doc.setHtml(json_to_html(obj))
return doc
def __init__(self, my_book, parent=None):
super().__init__(parent)
self.book = my_book
# Where we store the last-sought-for find string
self.find_text = None
# Register to read and write metadata
my_book.get_meta_manager().register( C.MD_NO, self.read_meta, self.save_meta )
# Set our only font (we don't care about the general font, only mono)
# n.b. this gets the Book's default size as it hasn't loaded a document
# yet.
self.setFont(fonts.get_fixed(my_book.get_font_size()))
# hook up to be notified of a change in font choice
fonts.notify_me(self.font_change)
# Set up our document not using the default one
a_document = QTextDocument()
a_document.setDocumentLayout(QPlainTextDocumentLayout(a_document))
self.setDocument(a_document)
# Turn off linewrap mode
self.setLineWrapMode(QPlainTextEdit.NoWrap)
# The following kludge allows us to get the correct highlight
# color on focus-in. For unknown reasons Qt makes us use the
# "Inactive" color group even after focus-in. See focusInEvent()
# and focusOutEvent() below.
self.palette_active = QPalette(self.palette())
self.palette_inactive = QPalette(self.palette())
b = self.palette().brush(QPalette.Active,QPalette.Highlight)
self.palette_active.setBrush(QPalette.Inactive,QPalette.Highlight,b)
# Set the cursor shape to IBeam -- no idea why this supposed default
# inherited from QTextEdit, doesn't happen. But it doesn't.
self.viewport().setCursor(Qt.IBeamCursor)
# Hook up a slot to notice that the document has changed its
# modification state.
self.document().modificationChanged.connect(self.yikes)
# Create our edit menu and stow it in the menu bar. Disable it.
ed_menu = QMenu(C.ED_MENU_EDIT,self)
ed_menu.addAction(C.ED_MENU_UNDO,self.undo,QKeySequence.Undo)
ed_menu.addAction(C.ED_MENU_REDO,self.redo,QKeySequence.Redo)
ed_menu.addSeparator()
ed_menu.addAction(C.ED_MENU_CUT,self.cut,QKeySequence.Cut)
ed_menu.addAction(C.ED_MENU_COPY,self.copy,QKeySequence.Copy)
ed_menu.addAction(C.ED_MENU_PASTE,self.paste,QKeySequence.Paste)
ed_menu.addSeparator()
ed_menu.addAction(C.ED_MENU_FIND,self.find_action,QKeySequence.Find)
ed_menu.addAction(C.ED_MENU_NEXT,self.find_next_action,QKeySequence.FindNext)
self.edit_menu = mainwindow.get_menu_bar().addMenu(ed_menu)
self.edit_menu.setVisible(False)
# In order to get focus events, we need to set focus policy
self.setFocusPolicy(Qt.StrongFocus)
def sizeHint(self, option, index):
self.initStyleOption(option, index)
doc = QTextDocument()
if index.column() in (NetworkTableModel.columns_types.index('address'),
NetworkTableModel.columns_types.index('port'),
NetworkTableModel.columns_types.index('api')):
doc.setHtml(option.text)
else:
doc.setPlainText("")
doc.setTextWidth(option.rect.width())
return QSize(doc.idealWidth(), doc.size().height())
def searchPrev(self, txt, caseSensitive, wholeWord, regexp):
"""
Public method to search the previous occurrence of the given text.
@param txt text to search for
@type str
@param caseSensitive flag indicating to perform a case sensitive
search
@type bool
@param wholeWord flag indicating to search for whole words
only
@type bool
@param regexp flag indicating a regular expression search
@type bool
"""
self.__lastSearch = (txt, caseSensitive, wholeWord, regexp)
flags = QTextDocument.FindFlags(QTextDocument.FindBackward)
if caseSensitive:
flags |= QTextDocument.FindCaseSensitively
if wholeWord:
flags |= QTextDocument.FindWholeWords
if regexp:
ok = self.find(
QRegExp(
txt,
Qt.CaseSensitive if caseSensitive else Qt.CaseInsensitive),
flags)
else:
ok = self.find(txt, flags)
self.searchStringFound.emit(ok)
def sizeHint(self, option, index):
"""QStyledItemDelegate.sizeHint implementation
"""
options = QStyleOptionViewItem(option)
self.initStyleOption(options, index)
doc = QTextDocument()
if self._font is not None:
doc.setDefaultFont(self._font)
doc.setDocumentMargin(1)
# bad long (multiline) strings processing doc.setTextWidth(options.rect.width())
doc.setHtml(options.text)
return QSize(doc.idealWidth(), doc.size().height())
def sizeHint(self, option, index):
text = index.model().data(index)
doc = QTextDocument()
doc.setHtml(text)
width = index.model().data(index, Qt.UserRole + 1337)
doc.setTextWidth(width)
return QSize(doc.idealWidth(), doc.size().height())
def formatText(self, text, _type):
if not text:
return text
# if _type == "t2t":
# text = self.runT2T(text)
# elif _type == "txt":
# text = text.replace("\n", "<br>")
elif _type == "html":
doc = QTextDocument()
doc.setHtml(text)
text = doc.toPlainText()
# text = self.htmlBody(text)
return text
def sizeHint(self, option, index):
options = QStyleOptionViewItem(option)
self.initStyleOption(options,index)
doc = QTextDocument()
doc.setHtml(options.text)
doc.setTextWidth(options.rect.width())
return QSize(doc.idealWidth(), doc.size().height())
def test_highlighted(qtbot):
"""Make sure highlighting works.
Note that with Qt 5.11.3 and > 5.12.1 we need to call setPlainText *after*
creating the highlighter for highlighting to work. Ideally, we'd test
whether CompletionItemDelegate._get_textdoc() works properly, but testing
that is kind of hard, so we just test it in isolation here.
"""
doc = QTextDocument()
completiondelegate._Highlighter(doc, 'Hello', Qt.red)
doc.setPlainText('Hello World')
# Needed so the highlighting actually works.
edit = QTextEdit()
qtbot.addWidget(edit)
edit.setDocument(doc)
colors = [f.foreground().color() for f in doc.allFormats()]
assert QColor('red') in colors
def exportSource(self):
"""
Public method performing the export.
"""
filename = self._getFileName(self.tr("ODT Files (*.odt)"))
if not filename:
return
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
QApplication.processEvents()
tabSize = Preferences.getEditor("TabWidth")
if tabSize == 0:
tabSize = 4
wysiwyg = Preferences.getEditorExporter("ODT/WYSIWYG")
onlyStylesUsed = Preferences.getEditorExporter("ODT/OnlyStylesUsed")
tabs = Preferences.getEditorExporter("ODT/UseTabs")
# generate HTML of the source
generator = HTMLGenerator(self.editor)
html = generator.generate(
tabSize=tabSize,
useTabs=tabs,
wysiwyg=wysiwyg,
folding=False,
onlyStylesUsed=onlyStylesUsed,
titleFullPath=False
)
# convert HTML to ODT
doc = QTextDocument()
doc.setHtml(html)
writer = QTextDocumentWriter(filename)
ok = writer.write(doc)
QApplication.restoreOverrideCursor()
if not ok:
E5MessageBox.critical(
self.editor,
self.tr("Export source"),
self.tr(
"""<p>The source could not be exported to"""
""" <b>{0}</b>.</p>""").format(filename))
def paint(self, painter, option, index):
text = index.data()
doc = QTextDocument()
doc.setHtml(text)
doc.setTextWidth(option.rect.width())
painter.save()
painter.translate(option.rect.x(), option.rect.y())
doc.drawContents(painter)
painter.restore()
index.model().setData(index, option.rect.width(), Qt.UserRole + 1337)
def paint(self, painter, option, index):
text = index.model().data(index, Qt.DisplayRole)
palette = QApplication.palette()
document = QTextDocument()
# if option.state & QStyle.State_Selected:
# document.setHtml("<p <center <font color={}>{}</font></center></p>".format(
# palette.highlightedText().color().name(), text))
# else:
document.setPlainText(text)
if index.column() == 1:
document.setTextWidth(350)
elif index.column() == 2:
document.setTextWidth(150)
to = QTextOption()
painter.save()
painter.translate(option.rect.x(), option.rect.y())
document.drawContents(painter)
painter.restore()
def savePdf(self,fileName):
pt = QPdfWriter(fileName)
# pt.logicalDpiX
pt.setPageSize(QPagedPaintDevice.A4)
# print('resolution',pt.resolution())
pt.setResolution(10000)
# print('resolution',pt.resolution())
textDocument = QTextDocument()
textDocument.setHtml(self.pcontext.thtmlGet())
textDocument.print_(pt)
textDocument.end()
print('pdf creat = ',fileName)
def paint(self, painter, option, index):
text = index.model().data(index, Qt.DisplayRole)
palette = QApplication.palette()
document = QTextDocument()
if option.state & QStyle.State_Selected:
document.setHtml("<p <center <font size={} font color={}>{}"
"</font></center></p>".format(
"5", palette.highlightedText().color().name(), text))
else:
document.setPlainText(text)
painter.save()
painter.translate(option.rect.x(), option.rect.y())
document.drawContents(painter)
painter.restore()
def sizeHint(self, option, index):
fm = option.fontMetrics
if index.column() == residNum:
return QSize(fm.width("9,999,999"), fm.height())
if index.column() == residName:
text = index.model().data(index)
document = QTextDocument()
document.setDefaultFont(option.font)
document.setHtml(text)
return QSize(document.idealWidth() + 5, fm.height())
return QStyledItemDelegate.sizeHint(self, option, index)
def __init__(self, fft_mainWindow,parent=None, screenDim=None):
super(ReportDialog, self).__init__(parent)
self.fft_mainWindow=fft_mainWindow
self.dataList = []
self.setupUi(self, screenDim)
self.screenDim = screenDim
self.document = QTextDocument()
#list that keeps track of only selected images
self.list = []
#list that contains all of the stored images
self.wholeList = OrderedSet()
self.savedfiles = None
self.currentModel = None
# settings
self.uCut = 0
self.lCut = 0
self.angleInc = 0
self.radStep = 0
# states
"""
0 -> single
1 -> multiple
2 -> append
"""
self.isReport = True
self.isSummary = False
self.reportOption = 2
self.merger = merger()
# printer
self.printer = QPrinter(QPrinter.PrinterResolution)
# Signals and slots:
self.do_excel.connect(self.exportExcel)
self.webView = QtWebKitWidgets.QWebView()
# self.checkBox_report.stateChanged.connect(self.topLogicHandler)
self.checkBox_summary.stateChanged.connect(self.topLogicHandler)
self.radio_multiple.toggled.connect(self.toggleHandler)
self.radio_single.toggled.connect(self.toggleHandler)
self.radio_append.toggled.connect(self.toggleHandler)
self.buttonBox.button(QDialogButtonBox.Ok).clicked.connect(self.exportHandler)
self.do_print.connect(self.print)
self.rejected.connect(self.resetOptions)
self.topLogicHandler()
def paint(self, painter, option, index):
"""QStyledItemDelegate.paint implementation
"""
option.state &= ~QStyle.State_HasFocus # never draw focus rect
option.state |= QStyle.State_Active # draw fuzzy-open completion as focused, even if focus is on the line edit
options = QStyleOptionViewItem(option)
self.initStyleOption(options, index)
style = QApplication.style() if options.widget is None else options.widget.style()
doc = QTextDocument()
if self._font is not None:
doc.setDefaultFont(self._font)
doc.setDocumentMargin(1)
doc.setHtml(options.text)
# bad long (multiline) strings processing doc.setTextWidth(options.rect.width())
options.text = ""
style.drawControl(QStyle.CE_ItemViewItem, options, painter)
ctx = QAbstractTextDocumentLayout.PaintContext()
# Highlighting text if item is selected
if option.state & QStyle.State_Selected:
ctx.palette.setColor(QPalette.Text, option.palette.color(QPalette.Active, QPalette.Text))
textRect = style.subElementRect(QStyle.SE_ItemViewItemText, options)
painter.save()
painter.translate(textRect.topLeft())
painter.setClipRect(textRect.translated(-textRect.topLeft()))
doc.documentLayout().draw(painter, ctx)
painter.restore()
def paint(self, painter, option, index):
"""QStyledItemDelegate.paint implementation
"""
option.state &= ~QStyle.State_HasFocus # never draw focus rect
options = QStyleOptionViewItem(option)
self.initStyleOption(options,index)
style = QApplication.style() if options.widget is None else options.widget.style()
doc = QTextDocument()
doc.setDocumentMargin(1)
doc.setHtml(options.text)
if options.widget is not None:
doc.setDefaultFont(options.widget.font())
# bad long (multiline) strings processing doc.setTextWidth(options.rect.width())
options.text = ""
style.drawControl(QStyle.CE_ItemViewItem, options, painter);
ctx = QAbstractTextDocumentLayout.PaintContext()
# Highlighting text if item is selected
if option.state & QStyle.State_Selected:
ctx.palette.setColor(QPalette.Text, option.palette.color(QPalette.Active, QPalette.HighlightedText))
textRect = style.subElementRect(QStyle.SE_ItemViewItemText, options)
painter.save()
painter.translate(textRect.topLeft())
"""Original example contained line
painter.setClipRect(textRect.translated(-textRect.topLeft()))
but text is drawn clipped with it on kubuntu 12.04
"""
doc.documentLayout().draw(painter, ctx)
painter.restore()
def _get_textdoc(self, index):
"""Create the QTextDocument of an item.
Args:
index: The QModelIndex of the item to draw.
"""
# FIXME we probably should do eliding here. See
# qcommonstyle.cpp:viewItemDrawText
text_option = QTextOption()
if self._opt.features & QStyleOptionViewItem.WrapText:
text_option.setWrapMode(QTextOption.WordWrap)
else:
text_option.setWrapMode(QTextOption.ManualWrap)
text_option.setTextDirection(self._opt.direction)
text_option.setAlignment(QStyle.visualAlignment(
self._opt.direction, self._opt.displayAlignment))
self._doc = QTextDocument(self)
if index.parent().isValid():
self._doc.setPlainText(self._opt.text)
else:
self._doc.setHtml('<b>{}</b>'.format(html.escape(self._opt.text)))
self._doc.setDefaultFont(self._opt.font)
self._doc.setDefaultTextOption(text_option)
self._doc.setDefaultStyleSheet(style.get_stylesheet("""
.highlight {
{{ color['completion.match.fg'] }}
}
"""))
self._doc.setDocumentMargin(2)
if index.column() == 0:
marks = index.data(basecompletion.Role.marks)
if marks is None:
return
for mark in marks:
cur = QTextCursor(self._doc)
cur.setPosition(mark[0])
cur.setPosition(mark[1], QTextCursor.KeepAnchor)
txt = cur.selectedText()
cur.removeSelectedText()
cur.insertHtml('<span class="highlight">{}</span>'.format(
html.escape(txt)))
def _get_textdoc(self, index):
"""Create the QTextDocument of an item.
Args:
index: The QModelIndex of the item to draw.
"""
# FIXME we probably should do eliding here. See
# qcommonstyle.cpp:viewItemDrawText
# https://github.com/qutebrowser/qutebrowser/issues/118
text_option = QTextOption()
if self._opt.features & QStyleOptionViewItem.WrapText:
text_option.setWrapMode(QTextOption.WordWrap)
else:
text_option.setWrapMode(QTextOption.ManualWrap)
text_option.setTextDirection(self._opt.direction)
text_option.setAlignment(QStyle.visualAlignment(
self._opt.direction, self._opt.displayAlignment))
if self._doc is not None:
self._doc.deleteLater()
self._doc = QTextDocument(self)
self._doc.setDefaultFont(self._opt.font)
self._doc.setDefaultTextOption(text_option)
self._doc.setDocumentMargin(2)
if index.parent().isValid():
view = self.parent()
pattern = view.pattern
columns_to_filter = index.model().columns_to_filter(index)
if index.column() in columns_to_filter and pattern:
pat = re.escape(pattern).replace(r'\ ', r'|')
if self._opt.state & QStyle.State_Selected:
color = config.val.colors.completion.item.selected.match.fg
else:
color = config.val.colors.completion.match.fg
_Highlighter(self._doc, pat, color)
self._doc.setPlainText(self._opt.text)
else:
self._doc.setHtml(
'<span style="font: {};">{}</span>'.format(
html.escape(config.val.fonts.completion.category),
html.escape(self._opt.text)))
def _get_textdoc(self, index):
"""Create the QTextDocument of an item.
Args:
index: The QModelIndex of the item to draw.
"""
# FIXME we probably should do eliding here. See
# qcommonstyle.cpp:viewItemDrawText
# https://github.com/The-Compiler/qutebrowser/issues/118
text_option = QTextOption()
if self._opt.features & QStyleOptionViewItem.WrapText:
text_option.setWrapMode(QTextOption.WordWrap)
else:
text_option.setWrapMode(QTextOption.ManualWrap)
text_option.setTextDirection(self._opt.direction)
text_option.setAlignment(QStyle.visualAlignment(
self._opt.direction, self._opt.displayAlignment))
if self._doc is not None:
self._doc.deleteLater()
self._doc = QTextDocument(self)
self._doc.setDefaultFont(self._opt.font)
self._doc.setDefaultTextOption(text_option)
self._doc.setDefaultStyleSheet(style.get_stylesheet("""
.highlight {
color: {{ color['completion.match.fg'] }};
}
"""))
self._doc.setDocumentMargin(2)
if index.parent().isValid():
pattern = index.model().pattern
columns_to_filter = index.model().srcmodel.columns_to_filter
if index.column() in columns_to_filter and pattern:
repl = r'<span class="highlight">\g<0></span>'
text = re.sub(re.escape(pattern).replace(r'\ ', r'.*'),
repl, self._opt.text, flags=re.IGNORECASE)
self._doc.setHtml(text)
else:
self._doc.setPlainText(self._opt.text)
else:
self._doc.setHtml('<b>{}</b>'.format(html.escape(self._opt.text)))
