Exemplo n.º 1
0
	def update(self, _pageFormat, _mmPageMargins=QMarginsF()):
		self.m_pageFormat = _pageFormat

		self.m_mmPageSize = QPageSize(self.m_pageFormat).rect(QPageSize.Millimeter).size()
		self.m_mmPageMargins = _mmPageMargins

		# Calculate values in pixels
		x = True; y = False
		self.m_pxPageSize = QSizeF(self.mmToPx(self.m_mmPageSize.width(), x), self.mmToPx(self.m_mmPageSize.height(), y))
		self.m_pxPageMargins = QMarginsF(self.mmToPx(self.m_mmPageMargins.left(), x), self.mmToPx(self.m_mmPageMargins.top(), y), self.mmToPx(self.m_mmPageMargins.right(), x), self.mmToPx(self.m_mmPageMargins.bottom(), y))
Exemplo n.º 2
0
 def paint(self, painter, *args, **kwargs):
     if self.hovered:
         margin = QMarginsF(7, 5, 7, 5)
     else:
         margin = QMarginsF(3, 0, 3, 0)
     box = self.boundingRect().marginsAdded(margin)
     path = QPainterPath()
     path.addRoundedRect(box, 5, 5)
     painter.fillPath(path, self.background_color)
     super().paint(painter, *args, **kwargs)
Exemplo n.º 3
0
    def __init__(self, page_width, page_height, crop_margin_width=0 * mm):
        self.page_width = page_width
        self.page_height = page_height
        self.margin_width = crop_margin_width
        self.include_crop_marks = bool(crop_margin_width)

        QApplication(['my-q-application'])
        f = QFontDatabase.addApplicationFont(
            '../../fonts/OldStandard-Regular.ttf')
        f = QFontDatabase.addApplicationFont('OldStandard-Italic.ttf')
        f = QFontDatabase.addApplicationFont('OldStandard-Bold.ttf')
        f = QFontDatabase.addApplicationFont('fonts/Inconsolata-Regular.ttf')
        f = QFontDatabase.addApplicationFont('fonts/UbuntuMono-R.ttf')
        f = QFontDatabase.addApplicationFont('../../fonts/GenBasB.ttf')
        f = QFontDatabase.addApplicationFont('../../fonts/GenBasR.ttf')
        #f = QFontDatabase.addApplicationFont('../../fonts/Inconsolata-Regular.ttf')
        # print(f)
        names = QFontDatabase.applicationFontFamilies(f)
        # print(names)
        self.writer = QPdfWriter('book.pdf')
        size = QSizeF(as_mm(2 * crop_margin_width + page_width),
                      as_mm(2 * crop_margin_width + page_height))
        print(size)
        self.writer.setPageSizeMM(size)
        margins = QMarginsF(as_mm(crop_margin_width), as_mm(crop_margin_width),
                            as_mm(crop_margin_width), as_mm(crop_margin_width))
        print(margins)
        self.writer.setPageMargins(margins, QPageLayout.Millimeter)
        self.painter = QPainter(self.writer)
        if self.include_crop_marks:
            self.draw_crop_marks()
Exemplo n.º 4
0
 def boundingRect(self):
     box = self.rect()
     viewBox = self.mapRectFromScene(box)
     margin = QMarginsF(*([self.penWidth] * 4))
     viewBox += margin
     box = self.mapRectToScene(viewBox)
     return box
Exemplo n.º 5
0
def print_pdf(page: QWebEngineView, filename):
    page.page().printToPdf(
        filename,
        QPageLayout(QPageSize(QPageSize.A4), QPageLayout.Portrait,
                    QMarginsF(5 * mm, 5 * mm, 5 * mm, 5 * mm)))
    page.page().pdfPrintingFinished.connect(
        lambda file_path, success: app.quit())
Exemplo n.º 6
0
    def save_image_to(self,
                      path,
                      top_margin=50,
                      bottom_margin=50,
                      left_margin=50,
                      right_margin=50):

        margins = QMarginsF(left_margin, top_margin, right_margin,
                            bottom_margin)

        oldRect = self.scene().sceneRect()
        minRect = self.scene().itemsBoundingRect()
        imgRect = minRect.marginsAdded(margins)

        image = QImage(imgRect.size().toSize(), QImage.Format_ARGB32)
        image.fill(Qt.white)
        painter = QPainter(image)

        painter.setRenderHints(QPainter.Antialiasing
                               | QPainter.SmoothPixmapTransform
                               | QPainter.HighQualityAntialiasing)

        # draw the image
        self.scene().setSceneRect(imgRect)
        self.scene().render(painter)
        image.save(path)

        # cleanup
        painter.end()

        # restore the old scene rect
        self.scene().setSceneRect(oldRect)
Exemplo n.º 7
0
 def paint(self, painter, *args, **kwargs):
     margin = QMarginsF(3, 0, 3, 0)
     box = self.boundingRect().marginsAdded(margin)
     path = QPainterPath()
     path.addRoundedRect(box, 5, 5)
     painter.fillPath(path, QColor(*self.background_color))
     super().paint(painter, *args, **kwargs)
Exemplo n.º 8
0
 def _boundingRect(self):
     bounding_rect = self.childrenBoundingRect().marginsAdded(self.margins)
     if self.qblock_annotations:
         # Hack to keep the arrows centered on the graph blocks.
         hack_right_margin = QMarginsF(0, 0, self.qblock_annotations.width,
                                       0)
         return bounding_rect.marginsAdded(hack_right_margin)
     return bounding_rect
Exemplo n.º 9
0
    def paintPageNumbers(self):
        # Page numbers are drawn only when the editor is in page mode,
        # if fields are set and the option to display numbers is enabled
        if (self.m_usePageMode
                and not self.m_pageMetrics.pxPageMargins().isNull()
                and self.m_showPageNumbers):

            pageWidth = self.m_pageMetrics.pxPageSize().width()
            pageHeight = self.m_pageMetrics.pxPageSize().height()
            pageMargins = QMarginsF(self.m_pageMetrics.pxPageMargins())

            p = QPainter(self.viewport())
            font = QFont()
            font.setPointSize(10)
            font.setFamily('Calibri')
            p.setFont(font)
            p.setPen(QPen(self.palette().text(), 1))

            # The current height and width are displayed on the screen.
            curHeight = pageHeight - (self.verticalScrollBar().value() %
                                      pageHeight)

            # The start of the field must take into account the scrollbar offset.
            leftMarginPosition = pageMargins.left() - self.horizontalScrollBar(
            ).value()

            # Total field width
            marginWidth = pageWidth - pageMargins.left() - pageMargins.right()

            # The number of the first page to see.
            pageNumber = self.verticalScrollBar().value() / pageHeight + 1

            # Add 0.3 to pageNumber before emitting
            # to announce page when it is about halfway up the screen
            self.pageInfo.emit(
                (int(pageNumber + 0.3),
                 int(self.verticalScrollBar().maximum() / pageHeight + 1)))

            # Paint page numbers while there are remotely more visible pages
            while (curHeight < pageHeight + self.height()):

                # Define the space for top page number; paint number
                topMarginRect = QRectF(leftMarginPosition,
                                       curHeight - pageHeight, marginWidth,
                                       pageMargins.top())
                self.paintPageNumber(p, topMarginRect, True, pageNumber)

                # Define the space for bottom page number; paint number
                bottomMarginRect = QRectF(leftMarginPosition,
                                          curHeight - pageMargins.bottom(),
                                          marginWidth, pageMargins.bottom())
                self.paintPageNumber(p, bottomMarginRect, False, pageNumber)

                # Go to next page
                pageNumber += 1
                curHeight += pageHeight
Exemplo n.º 10
0
 def testWrite(self):
     temporaryFile = QTemporaryFile(QDir.tempPath() +
                                    "/pdfwriter_test_XXXXXX.pdf")
     self.assertTrue(temporaryFile.open())
     pdfWriter = QPdfWriter(temporaryFile)
     pdfWriter.setPageLayout(
         QPageLayout(QPageSize(QPageSize.A4), QPageLayout.Portrait,
                     QMarginsF(10, 10, 10, 10)))
     doc = QTextDocument("Some text")
     doc.print_(pdfWriter)
     temporaryFile.close()
     self.assertTrue(temporaryFile.size() > 0)
Exemplo n.º 11
0
 def shrink_if_needed(self):
     """Shrinks the scene rectangle if it is considerably larger than the area occupied by items."""
     items_rect = self.itemsBoundingRect()
     # Margins from initial Design View scene size.
     # We don't want to shrink the scene immediately when user moves an item on a fresh scene.
     margins = QMarginsF(self._horizontal_threshold,
                         self._vertical_threshold,
                         self._horizontal_threshold,
                         self._vertical_threshold)
     acceptable_items_rect = items_rect.marginsAdded(margins)
     scene_rect = self.sceneRect()
     if not acceptable_items_rect.contains(scene_rect):
         self.setSceneRect(acceptable_items_rect.intersected(scene_rect))
Exemplo n.º 12
0
 def redo(self):
     self.tabWidget.setCurrentIndex(self.tabIndex)
     self.tabWidget.getTableView(self.tabIndex).clearSelection()
     model = self.tabWidget.getCurrentTableModel()
     cellIndex = model.index(self.row, self.col)
     self.tabWidget.setCurrentSelectedCell(cellIndex)
     page = model.pageAtIndex(cellIndex)
     if page != self.page:
         filename = self.tabWidget.widget(self.tabIndex).filename
         pattern = os.path.join(os.path.dirname(filename),
                                "**", page + ".*")
         possibleNames = glob.glob(pattern, recursive=True)
         imageName = None
         for name in possibleNames:
             mtypes = mimetypes.guess_type(name)
             if isinstance(mtypes[0], str) and 'image' in mtypes[0]:
                 imageName = name
                 break
         if not imageName:
             self.messageLabel.setText(f"{page} image not found")
             return
         self.graphicsScene.removeAllItems()
         pixmap = QPixmap(imageName)
         self.graphicsScene.setPage(page, pixmap)
     if page != self.page or self.tabIndex != self.prevTabIndex:
         self.graphicsScene.removeAllBoxes()
         for tabIndex, pageData in enumerate(
                 self.tabWidget.pageDatas(page)):
             tabName = self.tabWidget.tabText(tabIndex)
             for rowIndex, rowData in pageData.iterrows():
                 label = rowData["label"]
                 color = self.tabWidget.color_map(tabIndex)[label]
                 self.graphicsScene.addBox(
                     tabIndex, tabName, rowIndex, page, label,
                     rowData["box"], color)
     box = self.graphicsScene.box(self.tabIndex, self.row)
     boundingRect = box.boundingRect()
     margin_size = min(boundingRect.width(), boundingRect.height()) * 2
     margin = QMarginsF(*([margin_size] * 4))
     viewRect = boundingRect + margin
     self.graphicsView.fitInView(viewRect, Qt.KeepAspectRatio)
     self.graphicsView.setFocus()
     self.comboBox.blockSignals(True)
     self.comboBox.setCurrentText(box.label)
     self.comboBox.setCurrentIndex(self.comboBox.findText(self.label))
     self.comboBox.blockSignals(False)
     self.setText(f"clicked row {self.tabIndex}:{self.row}")
Exemplo n.º 13
0
 def export(self, filename):
     self.printer = QPrinter()
     self.printer.setOutputFormat(QPrinter.PdfFormat)
     self.printer.setOutputFileName(filename)
     self.printer.setPageMargins(QMarginsF(0, 0, 0, 0))
     self.printer.setResolution(96)
     self.printer.setFullPage(True)
     pages = self.document['pages']
     if pages:
         page = pages[0]
         self.printer.setPageSizeMM(QSizeF(page.width / mm, page.height / mm))
     self.painter = QPainter()
     self.painter.begin(self.printer)
     self._isFirstPage = True
     for page in pages:
         self.exportPage(page)
         self._isFirstPage = False
     self.painter.end()
Exemplo n.º 14
0
    def __init__(self,
                 workspace,
                 func_addr,
                 disasm_view,
                 disasm,
                 infodock,
                 addr,
                 cfg_nodes,
                 out_branches,
                 scene,
                 parent=None,
                 container=None):
        super().__init__(parent=parent, container=container)
        # initialization
        self.workspace = workspace
        self.func_addr = func_addr
        self.disasm_view = disasm_view
        self.disasm = disasm
        self.infodock = infodock
        self.variable_manager = infodock.variable_manager
        self.addr = addr
        self.cfg_nodes = cfg_nodes
        self.out_branches = out_branches
        self._scene = scene
        self.margins = QMarginsF(self.LEFT_PADDING, self.TOP_PADDING,
                                 self.RIGHT_PADDING, self.BOTTOM_PADDING)

        self._config = Conf

        self.objects = []  # instructions and labels
        self._block_item = None  # type: QPainterPath
        self._block_item_obj = None  # type: QGraphicsPathItem
        self.qblock_annotations = None
        self.addr_to_insns = {}
        self.addr_to_labels = {}

        self._init_widgets()

        self._objects_are_hidden = False

        self._create_block_item()

        self.setAcceptHoverEvents(True)
Exemplo n.º 15
0
    def init_scene(self, empty=False):
        """Resize scene and add a link drawer on scene.
        The scene must be cleared before calling this.

        Args:
            empty (boolean): True when creating a new project
        """
        self.link_drawer = LinkDrawer(self._toolbox)
        self.scene().addItem(self.link_drawer)
        if len(self.scene().items()) == 1:
            # Loaded project has no project items
            empty = True
        if not empty:
            # Reset scene rectangle to be as big as the items bounding rectangle
            items_rect = self.scene().itemsBoundingRect()
            margin_rect = items_rect.marginsAdded(QMarginsF(20, 20, 20, 20))  # Add margins
            self.scene().setSceneRect(margin_rect)
        else:
            rect = QRectF(0, 0, 401, 301)
            self.scene().setSceneRect(rect)
        self.scene().update()
        self.reset_zoom()
Exemplo n.º 16
0
    def _generate_hover_region(self):
        """
        Paint the memory region indicator.
        """
        if self._map_hover_region_item:
            self.scene().removeItem(self._map_hover_region_item)
            self._map_hover_region_item = None

        mr = self._map_hover_region
        if mr is None:
            return

        pw = 1.0
        hpw = pw / 2
        pen = QPen(Qt.red)
        pen.setWidth(pw)
        r = self._get_region_rect(mr)
        r = r.marginsRemoved(QMarginsF(hpw, hpw, hpw, hpw))
        item = QGraphicsRectItem(r, parent=self)
        item.setPen(pen)
        item.setZValue(self.ZVALUE_HOVER)
        self._map_hover_region_item = item
Exemplo n.º 17
0
    def on_actionSave_Document_triggered(self):
        print("on_actionSave_Document_triggered")
        ui = self.ui
        fileName = "./q_text-document-integration.pdf"
        #fileName = QFileDialog.getSaveFileName(self, "Save document...", qApp.applicationDirPath(), "*.pdf", None)
        #if fileName == None:
        #    print("No file")
        #    return
        #fileName = fileName[0]+".pdf"
        print("FILENAMKE=", fileName)

        printer = QPrinter()
        printer.setOutputFormat(QPrinter.PdfFormat)
        printer.setOutputFileName(fileName)
        pageMargins = QMargins(20, 20, 20, 20)
        pageLayout = QPageLayout()
        pageLayout.setMode(QPageLayout.StandardMode)
        pageLayout.setOrientation(QPageLayout.Portrait)
        pageLayout.setPageSize(QPageSize(QPageSize.A4))
        pageLayout.setUnits(QPageLayout.Millimeter)
        pageLayout.setMargins(QMarginsF(pageMargins))
        printer.setPageLayout(pageLayout)
        ui.textEdit.document().setPageSize(printer.pageRect().size())
        ui.textEdit.document().print_(printer)
Exemplo n.º 18
0
 def boundingRect(self):
     half_pen_width = self.PEN_WIDTH / 2
     margins = QMarginsF(half_pen_width, half_pen_width, half_pen_width,
                         half_pen_width)
     return self._scene_rect.marginsAdded(margins)
Exemplo n.º 19
0
def _pin_pos(rect, x, y):
    margins = (_EXT_LENGTH, ) * 4
    rect = rect.marginsAdded(QMarginsF(*margins))
    return QPointF(rect.x() + rect.width() * x - Pin._SIZE.width() / 2,
                   rect.y() + rect.height() * y - Pin._SIZE.height() / 2)
Exemplo n.º 20
0
class PageMetrics():

	m_pageFormat = QPageSize.PageSizeId()
	m_mmPageSize = QSizeF()
	m_mmPageMargins = QMarginsF()
	m_pxPageSize = QSizeF()
	m_pxPageMargins = QMarginsF()

	def __init__(self):
		super(PageMetrics, self).__init__()

	def mmToInches(self, mm):
		return mm * 0.039370147

	def mmToPx(self, _mm, _x):
		return self.mmToInches(_mm) * (qApp.desktop().logicalDpiX() if _x else qApp.desktop().logicalDpiY())

	def pageSizeIdFromString(self, _from):
		result = QPageSize.A4

		if (_from == "A0"):
			 result = QPageSize.A0
		elif (_from == "A1"):
			 result = QPageSize.A1
		elif (_from == "A2"):
			 result = QPageSize.A2
		elif (_from == "A3"):
			 result = QPageSize.A3
		elif (_from == "A4"):
			 result = QPageSize.A4
		elif (_from == "A5"):
			 result = QPageSize.A5
		elif (_from == "A6"):
			 result = QPageSize.A6
		else:
			Q_ASSERT_X(0, Q_FUNC_INFO, qPrintable("Undefined page size: " + _from))

		return result

	def stringFromPageSizeId(self, _pageSize):
		result = ""

		if(_pageSize == QPageSize.A0):
			result = "A0"
		elif (_pageSize == QPageSize.A1):
			result = "A1"
		elif (_pageSize == QPageSize.A2):
			result = "A2"
		elif (_pageSize == QPageSize.A3):
			result = "A3"
		elif (_pageSize == QPageSize.A4):
			result = "A4"
		elif (_pageSize == QPageSize.A5):
			result = "A5"
		elif (_pageSize == QPageSize.A6):
			result = "A6"
		else:
			Q_ASSERT_X(0, Q_FUNC_INFO, qPrintable("Undefined page size: " + QString.number(_pageSize)))
			
		return result

	def update(self, _pageFormat, _mmPageMargins=QMarginsF()):
		self.m_pageFormat = _pageFormat

		self.m_mmPageSize = QPageSize(self.m_pageFormat).rect(QPageSize.Millimeter).size()
		self.m_mmPageMargins = _mmPageMargins

		# Calculate values in pixels
		x = True; y = False
		self.m_pxPageSize = QSizeF(self.mmToPx(self.m_mmPageSize.width(), x), self.mmToPx(self.m_mmPageSize.height(), y))
		self.m_pxPageMargins = QMarginsF(self.mmToPx(self.m_mmPageMargins.left(), x), self.mmToPx(self.m_mmPageMargins.top(), y), self.mmToPx(self.m_mmPageMargins.right(), x), self.mmToPx(self.m_mmPageMargins.bottom(), y))

	def pageFormat(self):
		return self.m_pageFormat

	def mmPageSize(self):
		return self.m_mmPageSize

	def mmPageMargins(self):
		return self.m_mmPageMargins

	def pxPageSize(self):
		return QSizeF(self.m_pxPageSize.width(), self.m_pxPageSize.height())

	def pxPageMargins(self):
		return QMarginsF(self.m_pxPageMargins.left(), self.m_pxPageMargins.top(), self.m_pxPageMargins.right(), self.m_pxPageMargins.bottom())
Exemplo n.º 21
0
	def pxPageMargins(self):
		return QMarginsF(self.m_pxPageMargins.left(), self.m_pxPageMargins.top(), self.m_pxPageMargins.right(), self.m_pxPageMargins.bottom())
Exemplo n.º 22
0
 def _boundingRect(self):
     cbr = self.childrenBoundingRect()
     margins = QMarginsF(self.LEFT_PADDING, self.TOP_PADDING,
                         self.RIGHT_PADDING, self.BOTTOM_PADDING)
     return cbr.marginsAdded(margins)
Exemplo n.º 23
0
Arquivo: main.py Projeto: nwagu/pablo
    def __init__(self, fileName=None):
        super(MainWindow, self).__init__()

        self.curFile = ''
        self.curPage = (
            0, 0
        )  # Tuple containing current page and total pages of the current file

        self.setWindowTitle('Pablo Editor')
        self.setWindowIcon(QIcon(
            GenUtils.resource_path('src/images/icon.ico')))
        self.setWindowState(Qt.WindowFullScreen)
        self.setWindowState(Qt.WindowMaximized)
        # available_geometry = app.desktop().availableGeometry(self)
        # self.resize(available_geometry.width(), available_geometry.height())
        self.readSettings()

        self.dropView = dropview.DropView()

        self.paged_text_edit = pagedtextedit.PagedTextEdit(self.dropView)
        # The textedit must be transparent; the white pages are painted in paintEvent() function
        self.paged_text_edit.setStyleSheet(
            "QTextEdit { background-color: transparent }")

        self.paged_text_edit.setFrameStyle(
            QFrame.NoFrame)  # Removes a border-like line around the TextEdit

        doc = QTextDocument()
        font = QFont()
        font.setPointSize(12)
        font.setFamily('Calibri')
        doc.setDefaultFont(font)
        # doc.setDefaultStyleSheet("body { font-color: black; font-family: Calibri; font-size: 12;} ")
        self.paged_text_edit.setDocument(doc)
        self.paged_text_edit.setPageFormat(QPageSize.A5Extra)
        self.paged_text_edit.setPageMargins(QMarginsF(15, 15, 15, 15))
        self.paged_text_edit.setUsePageMode(True)
        self.paged_text_edit.setPageNumbersAlignment(Qt.AlignBottom
                                                     | Qt.AlignCenter)

        self.text_edit_layout = QHBoxLayout()
        self.text_edit_layout.setAlignment(Qt.AlignTop | Qt.AlignLeft)

        self.text_edit_layout.setMargin(0)
        self.paged_text_edit.setLayout(self.text_edit_layout)

        # This below block of code prevents undoing the setDocumentMargin() and setFrameformat()
        # methods in the aboutUpdateDocumentGeometry function
        self.paged_text_edit.aboutUpdateDocumentGeometry()
        # self.paged_text_edit.document().clearUndoRedoStack() # this does not work
        # These commands work
        self.paged_text_edit.document().setUndoRedoEnabled(False)
        self.paged_text_edit.document().setUndoRedoEnabled(True)

        self.setCentralWidget(self.dropView)

        self.dropView.addWidget(self.paged_text_edit)
        self.dropView.setCurrentWidget(self.paged_text_edit)

        self._setup_components()

        self.setCurrentFile('')
        self.paged_text_edit.document().contentsChanged.connect(
            self.documentWasModified)
        self.paged_text_edit.currentCharFormatChanged.connect(
            self.updateFontWidgets)
        self.paged_text_edit.cursorPositionChanged.connect(
            self.updatePositions)
        self.paged_text_edit.pageInfo.connect(self.readPageInfo)

        self.statusBar.writeMessageOnStatus("Ready", 10000)
Exemplo n.º 24
0
 def __init__(self, path):
     self.painter = None
     self.writer = QPdfWriter(path)
     margins = QMarginsF(0, 0, 0, 0)
     self.writer.setPageMargins(margins, QPageLayout.Millimeter)