From dab09477c8618247e8d81114c1256aea60290c9b Mon Sep 17 00:00:00 2001 From: chili-b Date: Sat, 2 Oct 2021 21:07:56 -0400 Subject: [PATCH 1/3] New package: python3-ly-0.9.7 Python modules parse, manipulate or create documents in LilyPond format. Depended upon by the Frescobaldi LilyPond editor. --- srcpkgs/python3-ly/template | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 srcpkgs/python3-ly/template diff --git a/srcpkgs/python3-ly/template b/srcpkgs/python3-ly/template new file mode 100644 index 000000000000..a795013096db --- /dev/null +++ b/srcpkgs/python3-ly/template @@ -0,0 +1,14 @@ +# Template file for 'python3-ly' +pkgname=python3-ly +version=0.9.7 +revision=1 +wrksrc="python-ly-${version}" +build_style=python3-module +hostmakedepends="python3-setuptools" +short_desc="Modules to parse, manipulate or create documents in LilyPond format" +maintainer="chili-b " +license="GPL-3.0-or-later" +homepage="https://github.com/frescobaldi/python-ly" +changelog="https://github.com/frescobaldi/python-ly/blob/v${version}/ChangeLog" +distfiles="${PYPI_SITE}/p/python-ly/python-ly-${version}.tar.gz" +checksum=d4d2b68eb0ef8073200154247cc9bd91ed7fb2671ac966ef3d2853281c15d7a8 From e478464b9df16e9a0aeeed565278e304e106c0ea Mon Sep 17 00:00:00 2001 From: chili-b Date: Sun, 10 Oct 2021 15:20:53 -0400 Subject: [PATCH 2/3] New package: python3-poppler-qt5-0.75.0 --- srcpkgs/python3-poppler-qt5/template | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 srcpkgs/python3-poppler-qt5/template diff --git a/srcpkgs/python3-poppler-qt5/template b/srcpkgs/python3-poppler-qt5/template new file mode 100644 index 000000000000..efbd3c65d357 --- /dev/null +++ b/srcpkgs/python3-poppler-qt5/template @@ -0,0 +1,28 @@ +# Template file for 'python3-poppler-qt5' +pkgname=python3-poppler-qt5 +version=0.75.0 +revision=1 +wrksrc="python-poppler-qt5-${version}" +build_style=python3-module +hostmakedepends="python3-sip-devel pkg-config qt5-devel poppler-qt5-devel + python3-PyQt5-devel python3-devel" +makedepends="python3-sip-devel pkg-config qt5-devel poppler-qt5-devel + python3-PyQt5-devel python3-devel" +depends="poppler-qt5 python3-PyQt5" +short_desc="Python bindings for libpoppler-qt5" +maintainer="chili-b " +license="LGPL-3.0-or-later" +homepage="https://github.com/frescobaldi/python-poppler-qt5" +changelog="https://github.com/frescobaldi/python-poppler-qt5/blob/v${version}/ChangeLog" +distfiles="${PYPI_SITE}/p/python-poppler-qt5/python-poppler-qt5-${version}.tar.gz" +checksum=ea0ec9ebe995705ab19a301290365652e62bab5c9b05db5697c7bf2173335107 + +do_build() { + # Cludge to fix build under armv7l, armv6l + if [[ $XBPS_TARGET_MACHINE == arm* ]]; then + export CFLAGS="-mtune=generic-armv7-a " + export CFLAGS+="-I${XBPS_CROSS_BASE}/${py3_inc}" + fi + + python setup.py build_ext --pyqt-sip-dir=/${py3_sitelib}/PyQt5/bindings +} From 9ad978d76f083c63cf55d4856fa22b4343321e62 Mon Sep 17 00:00:00 2001 From: chili-b Date: Sun, 10 Oct 2021 15:33:36 -0400 Subject: [PATCH 3/3] New package: frescobaldi-3.1.3 --- srcpkgs/frescobaldi/patches/python3_10.patch | 201 ++++++++++++++++++ .../frescobaldi/patches/python3_10_2.patch | 137 ++++++++++++ srcpkgs/frescobaldi/template | 20 ++ 3 files changed, 358 insertions(+) create mode 100644 srcpkgs/frescobaldi/patches/python3_10.patch create mode 100644 srcpkgs/frescobaldi/patches/python3_10_2.patch create mode 100644 srcpkgs/frescobaldi/template diff --git a/srcpkgs/frescobaldi/patches/python3_10.patch b/srcpkgs/frescobaldi/patches/python3_10.patch new file mode 100644 index 000000000000..c4248f38bca8 --- /dev/null +++ b/srcpkgs/frescobaldi/patches/python3_10.patch @@ -0,0 +1,201 @@ +# Python 3.10 made a change to how floats are cast to integers which breaks a +# lot of things in frescobaldi. This will supposedly be fixed by the time +# v3.2 releases, but for now we must rely on patching. +# +# Assuming that the issues are fixed upstream when they say they will be, this +# patch is to be removed when frescobaldi's next release comes out. +diff --git a/frescobaldi_app/qpageview/page.py b/frescobaldi_app/qpageview/page.py +index f93fa9e2..754d2736 100644 +--- a/frescobaldi_app/qpageview/page.py ++++ b/frescobaldi_app/qpageview/page.py +@@ -48,7 +48,7 @@ class AbstractPage(util.Rectangular): + + ...that normally do not change during its lifetime: + +- `pageWidth` the original width (by default in points, `dpi` is 72.0 ++ `pageWidth` the original width (by default in points, `dpi` is 72.0 + `pageHeight` the original height but can be changed at class level) + + ... that can be modified by the user (having defaults at the class level): +@@ -174,15 +174,15 @@ class AbstractPage(util.Rectangular): + + def defaultSize(self): + """Return the pageSize() scaled and rotated (if needed). +- ++ + Based on scaleX, scaleY, and computedRotation attributes. +- ++ + """ + s = QSizeF(self.pageWidth * self.scaleX, self.pageHeight * self.scaleY) + if self.computedRotation & 1: + s.transpose() + return s +- ++ + def updateSize(self, dpiX, dpiY, zoomFactor): + """Set the width and height attributes of the page. + +@@ -286,7 +286,7 @@ class AbstractPage(util.Rectangular): + + pdf = QPdfWriter(filename) + pdf.setCreator("qpageview") +- pdf.setResolution(resolution) ++ pdf.setResolution(int(resolution)) + + layout = pdf.pageLayout() + layout.setMode(layout.FullPageMode) +@@ -350,7 +350,7 @@ class AbstractPage(util.Rectangular): + svg.setFileName(filename) + else: + svg.setOutputDevice(filename) +- svg.setResolution(resolution) ++ svg.setResolution(int(resolution)) + svg.setSize(targetSize.toSize()) + svg.setViewBox(QRectF(0, 0, targetSize.width(), targetSize.height())) + return self.output(svg, source, paperColor) +@@ -381,31 +381,31 @@ class AbstractPage(util.Rectangular): + + def group(self): + """Return the group the page belongs to. +- ++ + This could be some document structure, so that different Page objects + could refer to the same graphical contents, preventing double caching. +- ++ + This object is used together with the value returned by ident() as a key + to cache the page. The idea is that the contents of the page are + uniquely identified by the objects returned by group() and ident(). +- ++ + This way, when the same document is opened in multiple page instances, + only one copy resides in the (global) cache. +- ++ + By default, the page object itself is returned. +- ++ + """ + return self +- ++ + def ident(self): + """Return a value that identifies the page within the group returned + by group(). +- ++ + By default, None is returned. +- ++ + """ + return None +- ++ + def mapToPage(self, width=None, height=None): + """Return a MapToPage object, that can map original to Page coordinates. + +@@ -426,10 +426,10 @@ class AbstractPage(util.Rectangular): + + def text(self, rect): + """Implement this method to get the text at the specified rectangle. +- ++ + The rectangle should be in page coordinates. The default implementation + simply returns an empty string. +- ++ + """ + return "" + +@@ -437,22 +437,22 @@ class AbstractPage(util.Rectangular): + """Implement this method to load our links.""" + from . import link + return link.Links() +- ++ + def links(self): + """Return the Links object, containing Link objects. +- ++ + Every Link denotes a clickable area on a Page, in coordinates 0.0-1.0. + The Links object makes it possible to quickly find a link on a Page. + This is cached after the first request, you should implement the + getLinks() method to load the links. +- ++ + """ + try: + return self._links + except AttributeError: + links = self._links = self.getLinks() + return links +- ++ + def linksAt(self, point): + """Return a list() of zero or more links touched by QPoint point. + +@@ -468,9 +468,9 @@ class AbstractPage(util.Rectangular): + + def linksIn(self, rect): + """Return an unordered set of links enclosed in rectangle. +- ++ + The rectangle is in page coordinates. +- ++ + """ + return self.links().inside(*self.mapFromPage(1, 1).rect(rect).getCoords()) + +@@ -481,9 +481,9 @@ class AbstractPage(util.Rectangular): + + class AbstractRenderedPage(AbstractPage): + """A Page that has a renderer that performs caching and painting. +- ++ + The renderer lives in the renderer attribute. +- ++ + """ + def __init__(self, renderer=None): + if renderer is not None: +diff --git a/frescobaldi_app/qpageview/poppler.py b/frescobaldi_app/qpageview/poppler.py +index 26768356..810dbca5 100644 +--- a/frescobaldi_app/qpageview/poppler.py ++++ b/frescobaldi_app/qpageview/poppler.py +@@ -259,7 +259,7 @@ class PopplerRenderer(render.AbstractRenderer): + (See AbstractPage.print().) + + """ +- source = self.map(key, page.pageRect()).mapRect(QRectF(*tile)) ++ source = self.map(key, page.pageRect()).mapRect(QRectF(*tile)).toRect() # rounded + target = QRectF(0, 0, tile.w, tile.h) + if key.rotation & 1: + target.setSize(target.size().transposed()) +diff --git a/frescobaldi_app/qpageview/scrollarea.py b/frescobaldi_app/qpageview/scrollarea.py +index 5a0c5631..6722a6db 100644 +--- a/frescobaldi_app/qpageview/scrollarea.py ++++ b/frescobaldi_app/qpageview/scrollarea.py +@@ -365,9 +365,9 @@ class ScrollArea(QAbstractScrollArea): + speed = speed * 1000 / self.scrollupdatespersec / time + # compute diff to scroll + sx = abs(speed.x()) +- diffx = sx * (sx + 1) / 2 ++ diffx = int(sx * (sx + 1) / 2) + sy = abs(speed.y()) +- diffy = sy * (sy + 1) / 2 ++ diffy = int(sy * (sy + 1) / 2) + if speed.x() < 0: diffx = -diffx + if speed.y() < 0: diffy = -diffy + self.kineticScrollBy(QPoint(diffx, diffy)) +@@ -444,8 +444,8 @@ class KineticScroller(Scroller): + dy = diff.y() + + # solve speed*(speed+1)/2 = delta to ensure 1+2+3+...+speed is as close as possible under delta.. +- sx = (math.sqrt(1 + 8 * abs(dx)) - 1) // 2 +- sy = (math.sqrt(1 + 8 * abs(dy)) - 1) // 2 ++ sx = int(math.sqrt(1 + 8 * abs(dx)) - 1) // 2 ++ sy = int(math.sqrt(1 + 8 * abs(dy)) - 1) // 2 + + # compute the amount of displacement still needed because we're dealing with integer values. + # Since this function is called for exact moves (not free scrolling) diff --git a/srcpkgs/frescobaldi/patches/python3_10_2.patch b/srcpkgs/frescobaldi/patches/python3_10_2.patch new file mode 100644 index 000000000000..fb8848316b4d --- /dev/null +++ b/srcpkgs/frescobaldi/patches/python3_10_2.patch @@ -0,0 +1,137 @@ +diff --git a/frescobaldi_app/qpageview/poppler.py b/frescobaldi_app/qpageview/poppler.py +index 17312d78..7b6699e5 100644 +--- a/frescobaldi_app/qpageview/poppler.py ++++ b/frescobaldi_app/qpageview/poppler.py +@@ -205,8 +205,8 @@ class PopplerRenderer(render.AbstractRenderer): + key.rotation, paperColor) + if multiplier == 2: + image = image.scaledToWidth(tile.w, Qt.SmoothTransformation) +- image.setDotsPerMeterX(xres * 39.37) +- image.setDotsPerMeterY(yres * 39.37) ++ image.setDotsPerMeterX(round(xres * 39.37)) ++ image.setDotsPerMeterY(round(yres * 39.37)) + return image + + def setRenderHints(self, doc): +diff --git a/frescobaldi_app/qpageview/render.py b/frescobaldi_app/qpageview/render.py +index a8c00de1..79a6a10b 100644 +--- a/frescobaldi_app/qpageview/render.py ++++ b/frescobaldi_app/qpageview/render.py +@@ -241,7 +241,7 @@ class AbstractRenderer: + key = self.key(page, ratio) + + # paint rect in tile coordinates +- target = QRect(rect.x() * ratio, rect.y() * ratio, rect.width() * ratio, rect.height() * ratio) ++ target = QRect(round(rect.x() * ratio), round(rect.y() * ratio), round(rect.width() * ratio), round(rect.height() * ratio)) + + # tiles to paint + tiles = [t for t in self.tiles(key.width, key.height) if QRect(*t) & target] +diff --git a/frescobaldi_app/qpageview/scrollarea.py b/frescobaldi_app/qpageview/scrollarea.py +index 6f4dcaf1..027ce7e0 100644 +--- a/frescobaldi_app/qpageview/scrollarea.py ++++ b/frescobaldi_app/qpageview/scrollarea.py +@@ -186,9 +186,9 @@ class ScrollArea(QAbstractScrollArea): + else: + viewport = self.viewport() + vbar.setRange(0, h - viewport.height()) +- vbar.setPageStep(viewport.height() * .9) ++ vbar.setPageStep(round(viewport.height() * .9)) + hbar.setRange(0, w - viewport.width()) +- hbar.setPageStep(viewport.width() * .9) ++ hbar.setPageStep(round(viewport.width() * .9)) + + def scrollOffset(self): + """Return the current scroll offset.""" +@@ -295,7 +295,7 @@ class ScrollArea(QAbstractScrollArea): + """Begin a scrolling operation using the specified scroller.""" + self._scroller = scroller + if self._scrollTimer is None: +- self._scrollTimer = self.startTimer(1000 / self.scrollupdatespersec) ++ self._scrollTimer = self.startTimer(round(1000 / self.scrollupdatespersec)) + + def stopScrolling(self): + """Stop scrolling.""" +diff --git a/frescobaldi_app/qpageview/shadow.py b/frescobaldi_app/qpageview/shadow.py +index c7d1c8d5..4f9cc1bf 100644 +--- a/frescobaldi_app/qpageview/shadow.py ++++ b/frescobaldi_app/qpageview/shadow.py +@@ -37,10 +37,10 @@ class ShadowViewMixin: + + def paintEvent(self, ev): + if self.dropShadowEnabled: +- width = self._pageLayout.spacing / 2 ++ width = round(self._pageLayout.spacing / 2) + # make the rect slightly larger, so we "see" shadow of pages that + # would be outside view normally. +- rect = ev.rect().adjusted(-width, -width, width / 2, width / 2) ++ rect = ev.rect().adjusted(-width, -width, width // 2, width // 2) + painter = QPainter(self.viewport()) + for page, rect in self.pagesToPaint(rect, painter): + self.drawDropShadow(page, painter, width) +@@ -53,14 +53,14 @@ class ShadowViewMixin: + + """ + width = round(width) +- rect = page.rect().adjusted(width / 2, width / 2, 0, 0) ++ rect = page.rect().adjusted(width // 2, width // 2, 0, 0) + color = QColor(Qt.black) + pen = QPen() + pen.setWidth(1) + pen.setJoinStyle(Qt.MiterJoin) + for i in range(width): + f = (width-i)/width +- color.setAlpha(200**f + 55*f) ++ color.setAlpha(round(200**f + 55*f)) + pen.setColor(color) + painter.setPen(pen) + painter.drawRect(rect.adjusted(-i, -i, i, i)) +diff --git a/frescobaldi_app/viewmanager.py b/frescobaldi_app/viewmanager.py +index e1294c91..046c70df 100644 +--- a/frescobaldi_app/viewmanager.py ++++ b/frescobaldi_app/viewmanager.py +@@ -332,7 +332,7 @@ class ViewManager(QSplitter): + splitter.setOrientation(orientation) + size = splitter.sizes()[0] + splitter.addWidget(newspace) +- splitter.setSizes([size / 2, size / 2]) ++ splitter.setSizes([size // 2, size // 2]) + elif splitter.orientation() == orientation: + index = splitter.indexOf(viewspace) + splitter.insertWidget(index + 1, newspace) +@@ -346,7 +346,7 @@ class ViewManager(QSplitter): + splitter.setSizes(sizes) + size = newsplitter.sizes()[0] + newsplitter.addWidget(newspace) +- newsplitter.setSizes([size / 2, size / 2]) ++ newsplitter.setSizes([size // 2, size // 2]) + self._viewSpaces.insert(0, newspace) + newspace.showDocument(viewspace.document()) + if active: +diff --git a/frescobaldi_app/widgets/linenumberarea.py b/frescobaldi_app/widgets/linenumberarea.py +index f097726c..93970e7d 100644 +--- a/frescobaldi_app/widgets/linenumberarea.py ++++ b/frescobaldi_app/widgets/linenumberarea.py +@@ -80,7 +80,7 @@ class LineNumberArea(QWidget): + if geom.top() >= ev.rect().bottom(): + break + if block.isVisible() and geom.bottom() > ev.rect().top() + 1: +- rect.moveTop(geom.top()) ++ rect.moveTop(round(geom.top())) + text = format(block.blockNumber() + 1, 'd') + painter.drawText(rect, Qt.AlignRight, text) + block = block.next() +diff --git a/frescobaldi_app/widgets/progressbar.py b/frescobaldi_app/widgets/progressbar.py +index 670bf0f5..6cd9b31d 100644 +--- a/frescobaldi_app/widgets/progressbar.py ++++ b/frescobaldi_app/widgets/progressbar.py +@@ -71,8 +71,8 @@ class TimedProgressBar(QProgressBar): + """ + self._hideTimer.stop() + self._timeline.stop() +- self._timeline.setDuration(total * 1000) +- self._timeline.setCurrentTime(elapsed * 1000) ++ self._timeline.setDuration(round(total * 1000)) ++ self._timeline.setCurrentTime(round(elapsed * 1000)) + self.setValue(self._timeline.currentFrame()) + self._timeline.resume() + if self._hideWhileIdle and not self._hidden: diff --git a/srcpkgs/frescobaldi/template b/srcpkgs/frescobaldi/template new file mode 100644 index 000000000000..bf61cf1155c6 --- /dev/null +++ b/srcpkgs/frescobaldi/template @@ -0,0 +1,20 @@ +# Template file for 'frescobaldi' +pkgname=frescobaldi +version=3.1.3 +revision=1 +build_style=python3-module +make_check_target="check" +hostmakedepends="python3-setuptools gettext" +depends="python3-PyQt5 python3-PyQt5-svg poppler-qt5 portmidi + python3-cups python3-ly lilypond python3-poppler-qt5" +short_desc="Powerful, lightweight and easy to use LilyPond sheet music text editor" +maintainer="chili-b " +license="GPL-2.0-or-later" +homepage="https://frescobaldi.org/" +changelog="https://github.com/frescobaldi/frescobaldi/blob/v${version}/ChangeLog" +distfiles="https://github.com/frescobaldi/frescobaldi/archive/v${version}.tar.gz" +checksum=f97256ce15ab621593536e219584a2ed744c1933148ac7ed98fcef6a3a9510a6 + +pre_build() { + make -C linux +}