qet-mcp: size a folio for a sheet of paper (set_folio_border preset)

setFolioBorder(folio, "preset", "tabloid-landscape") picks the column and row counts and whole-number sizes that fill the sheet best without going over it, as one ChangeBorderCommand. The title block and headers are measured from the folio, so it holds for any template on either edge. Sizes stay whole because the folio properties panel edits them in whole pixels. Among fills within 1.5 pt of the sheet, the size nearest the current one wins: from a new folio tabloid landscape is 23 x 70 by 12 x 82, not 9 x 179 by 5 x 197. A0-A5, letter, legal, tabloid/ledger, each -portrait or -landscape; folioPresets() lists them, and folioBorder() reads "width" and "height" of the frame and title block. Every preset exports on its sheet; landscape ones rely on the previous commit, which turns a wide page before matching it to a sheet. The MCP server checks the name up front, probes for folioPresets(), and the op's note says what was chosen and the frame's size in points. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-04 01:44:13 +02:00 · 2026-10-02 22:26:14 +13:00
parent 797d502c0a
commit 0b4fc8beb0
5 changed files with 252 additions and 6 deletions
@@ -52,6 +52,8 @@
 #ifdef QET_HAS_QTPDF
 #include <QPdfDocument>
 #include <QPainter>
+#include <QPageSize>
+#include <cmath>
 #endif
 #include "../qetgraphicsitem/dynamicelementtextitem.h"
 #include "../qetgraphicsitem/independenttextitem.h"
@@ -3714,9 +3716,80 @@ QString QetScriptApi::folioBorder(int folioIndex, const QString &property) const
 	if (property == QLatin1String("rows"))            return QString::number(b.rows_count);
 	if (property == QLatin1String("row-height"))      return QString::number(b.rows_height);
 	if (property == QLatin1String("display-rows"))    return b.display_rows ? QStringLiteral("true") : QStringLiteral("false");
+	const QRectF r = diagrams.at(folioIndex)->border_and_titleblock.borderAndTitleBlockRect();
+	if (property == QLatin1String("width"))           return QString::number(r.width());
+	if (property == QLatin1String("height"))          return QString::number(r.height());
 	return QString();
 }

+namespace {
+/// The sheets "preset" knows, by the name it takes before -portrait or
+/// -landscape. Tabloid and ledger are the same 11 x 17 in sheet.
+const QList<QPair<QString, QPageSize::PageSizeId>> &folioPaper()
+{
+	static const QList<QPair<QString, QPageSize::PageSizeId>> p{
+		{QStringLiteral("a0"), QPageSize::A0}, {QStringLiteral("a1"), QPageSize::A1},
+		{QStringLiteral("a2"), QPageSize::A2}, {QStringLiteral("a3"), QPageSize::A3},
+		{QStringLiteral("a4"), QPageSize::A4}, {QStringLiteral("a5"), QPageSize::A5},
+		{QStringLiteral("letter"), QPageSize::Letter}, {QStringLiteral("legal"), QPageSize::Legal},
+		{QStringLiteral("tabloid"), QPageSize::Tabloid}, {QStringLiteral("ledger"), QPageSize::Tabloid}};
+	return p;
+}
+
+/**
+	The count (1-99) and whole size (20-200) of cells that fill @p available
+	without going over it. Any fill within two units of it will do -- a PDF
+	export rounds a page that close to a standard sheet up to the sheet
+	(QPageSize's fuzzy match allows 3 pt, and two units are 1.5 pt) -- and
+	among those the size nearest @p current wins, so the grid keeps the
+	look it had rather than turning into nine huge columns that happen to
+	divide the sheet exactly. Failing that, the fullest fill. False if not
+	even one cell of the smallest size fits.
+*/
+bool fitCells(qreal available, qreal current, int &count, qreal &size)
+{
+	constexpr qreal slack = 2.0;
+	int best_n = 0, best_s = 0, best_fill = 0;
+	bool best_close = false;
+	for (int s = 20; s <= 200; ++s) {
+		const int n = qMin(99, int(std::floor(available / s + 1e-9)));
+		if (n < 1) continue;
+		const int fill = n * s;
+		const bool close = fill >= available - slack;
+		bool better;
+		if (close != best_close)
+			better = close;
+		else if (close && qAbs(s - current) != qAbs(best_s - current))
+			better = qAbs(s - current) < qAbs(best_s - current);
+		else
+			better = fill > best_fill;
+		if (!best_n || better) {
+			best_n = n;
+			best_s = s;
+			best_fill = fill;
+			best_close = close;
+		}
+	}
+	if (!best_n) return false;
+	count = best_n;
+	size = best_s;
+	return true;
+}
+} // namespace
+
+/**
+	@brief QetScriptApi::folioPresets
+	The values setFolioBorder() takes for "preset".
+*/
+QStringList QetScriptApi::folioPresets() const
+{
+	QStringList names;
+	for (const auto &paper : folioPaper())
+		names << paper.first + QStringLiteral("-portrait")
+			  << paper.first + QStringLiteral("-landscape");
+	return names;
+}
+
 /**
 	@brief QetScriptApi::setFolioBorder
 	Change one field of a folio's frame through ChangeBorderCommand, as the
@@ -3727,6 +3800,9 @@ QString QetScriptApi::folioBorder(int folioIndex, const QString &property) const
 	tested, so it is left refused rather than assumed safe. The extremes
 	that are offered (99 x 99 cells, widths from 1 to 1000) were exported to
 	PNG and did not hang or crash.
+
+	"preset" sets all four at once for a sheet of paper, as one command:
+	see the class comment.
 */
 bool QetScriptApi::setFolioBorder(int folioIndex, const QString &property, const QString &value)
 {
@@ -3736,8 +3812,8 @@ bool QetScriptApi::setFolioBorder(int folioIndex, const QString &property, const
 		log(QStringLiteral("qet.%1: project is read-only").arg(caller));
 		return false;
 	}
-	if (!folioBorderNames().contains(property)) {
-		log(QStringLiteral("qet.%1: unknown property '%2'; expected one of %3")
+	if (!folioBorderNames().contains(property) && property != QLatin1String("preset")) {
+		log(QStringLiteral("qet.%1: unknown property '%2'; expected one of %3, preset")
 			.arg(caller, property, folioBorderNames().join(QStringLiteral(", "))));
 		return false;
 	}
@@ -3748,7 +3824,45 @@ bool QetScriptApi::setFolioBorder(int folioIndex, const QString &property, const
 	const BorderProperties old_b = diagram->border_and_titleblock.exportBorder();
 	BorderProperties new_b = old_b;
 	bool ok = false;
-	if (property == QLatin1String("columns") || property == QLatin1String("rows")) {
+	if (property == QLatin1String("preset")) {
+		const QString v = value.toLower();
+		const int dash = v.lastIndexOf(QLatin1Char('-'));
+		const QString orientation = v.mid(dash + 1);
+		bool known = dash > 0 && (orientation == QLatin1String("portrait")
+								  || orientation == QLatin1String("landscape"));
+		QSizeF mm;
+		if (known) {
+			known = false;
+			for (const auto &paper : folioPaper()) {
+				if (paper.first != v.left(dash)) continue;
+				mm = QPageSize(paper.second).size(QPageSize::Millimeter);
+				known = true;
+			}
+		}
+		if (!known) {
+			log(QStringLiteral("qet.%1: unknown preset '%2'; expected one of %3")
+				.arg(caller, value, folioPresets().join(QStringLiteral(", "))));
+			return false;
+		}
+		if ((orientation == QLatin1String("landscape")) != (mm.width() > mm.height()))
+			mm.transpose();
+		// Scene units are pixels at 96 per inch, as the PDF export draws
+		// them; the export adds one for the frame's own line.
+		const qreal page_w = std::floor(mm.width()  / 25.4 * 96.0 + 1e-6) - 1;
+		const qreal page_h = std::floor(mm.height() / 25.4 * 96.0 + 1e-6) - 1;
+		// Whatever is not columns or rows -- the headers, and the title
+		// block on whichever edge it sits -- measured rather than assumed,
+		// since it depends on the template.
+		const QRectF r = diagram->border_and_titleblock.borderAndTitleBlockRect();
+		const qreal extra_w = r.width()  - old_b.columns_count * old_b.columns_width;
+		const qreal extra_h = r.height() - old_b.rows_count * old_b.rows_height;
+		if (!fitCells(page_w - extra_w, old_b.columns_width, new_b.columns_count, new_b.columns_width)
+			|| !fitCells(page_h - extra_h, old_b.rows_height, new_b.rows_count, new_b.rows_height)) {
+			log(QStringLiteral("qet.%1: preset '%2' leaves no room for a column or a row "
+							   "beside this folio's title block").arg(caller, value));
+			return false;
+		}
+	} else if (property == QLatin1String("columns") || property == QLatin1String("rows")) {
 		const int n = value.toInt(&ok);
 		if (!ok || n < 1 || n > 99) {
 			log(QStringLiteral("qet.%1: %2 must be a whole number from 1 to 99, not '%3'").arg(caller, property, value));
@@ -254,6 +254,17 @@ class QetGraphicsTableItem;
 	  which it does not, are left alone. Changing the project title is not
 	  undoable: the application sets it directly too.

+	  A seventh, write-only field, "preset", sizes the frame for a sheet of
+	  paper: "a4-landscape", "tabloid-portrait" and so on (folioPresets()
+	  lists them). It picks the column and row counts and whole-number
+	  sizes that fill the sheet best without going over it, keeping each
+	  size as near the current one as it can, and pushes them as one
+	  ChangeBorderCommand. Whole numbers because the folio properties panel
+	  edits these sizes in whole pixels: a fraction would be rounded off the
+	  first time someone opened it. Two read-only fields, "width" and
+	  "height", are the frame and title block together in scene units --
+	  what an export draws -- so a caller can check the result.
+
 	  A folio's title block @b template is a seventh, separate case:
 	  Diagram::setTitleBlockTemplate() resolves a name only against
 	  QETProject::embeddedTitleBlockTemplatesCollection() -- the same
@@ -538,6 +549,7 @@ class QetScriptApi : public QObject
 		Q_INVOKABLE bool setProjectTitle(const QString &title);
 		Q_INVOKABLE QString folioBorder(int folioIndex, const QString &property) const;
 		Q_INVOKABLE bool setFolioBorder(int folioIndex, const QString &property, const QString &value);
+		Q_INVOKABLE QStringList folioPresets() const;

 		// -- the conductor defaults of a folio (Folio properties > Conductors),
 		//    or with folioIndex -1, the project's defaults for new folios --