QPageSize Class

Die Klasse „QPageSize“ beschreibt die Größe und den Namen einer definierten Seitengröße. Mehr...

Header:	`#include <QPageSize>`

CMake:	`find_package(Qt6 REQUIRED COMPONENTS Gui)` `target_link_libraries(mytarget PRIVATE Qt6::Gui)`
qmake:	`QT += gui`

Liste aller Mitglieder, einschließlich geerbter Mitglieder

Öffentliche Typen

enum	PageSizeId { A0, A1, A2, A3, A4, …, LastPageSize }
enum	SizeMatchPolicy { FuzzyMatch, FuzzyOrientationMatch, ExactMatch }
enum	Unit { Millimeter, Point, Inch, Pica, Didot, Cicero }

Öffentliche Funktionen

	QPageSize()
	QPageSize(QPageSize::PageSizeId pageSize)
	QPageSize(const QSize &pointSize, const QString &name = QString(), QPageSize::SizeMatchPolicy matchPolicy = FuzzyMatch)
	QPageSize(const QSizeF &size, QPageSize::Unit units, const QString &name = QString(), QPageSize::SizeMatchPolicy matchPolicy = FuzzyMatch)
	QPageSize(const QPageSize &other)
	~QPageSize()
QSizeF	definitionSize() const
QPageSize::Unit	definitionUnits() const
QPageSize::PageSizeId	id() const
bool	isEquivalentTo(const QPageSize &other) const
bool	isValid() const
QString	key() const
QString	name() const
QRectF	rect(QPageSize::Unit units) const
QRect	rectPixels(int resolution) const
QRect	rectPoints() const
QSizeF	size(QPageSize::Unit units) const
QSize	sizePixels(int resolution) const
QSize	sizePoints() const
void	swap(QPageSize &other)
int	windowsId() const
QPageSize &	operator=(QPageSize &&other)
QPageSize &	operator=(const QPageSize &other)

Statische öffentliche Elemente

QSizeF	definitionSize(QPageSize::PageSizeId pageSizeId)
QPageSize::Unit	definitionUnits(QPageSize::PageSizeId pageSizeId)
QPageSize::PageSizeId	id(int windowsId)
QPageSize::PageSizeId	id(const QSize &pointSize, QPageSize::SizeMatchPolicy matchPolicy = FuzzyMatch)
QPageSize::PageSizeId	id(const QSizeF &size, QPageSize::Unit units, QPageSize::SizeMatchPolicy matchPolicy = FuzzyMatch)
QString	key(QPageSize::PageSizeId pageSizeId)
QString	name(QPageSize::PageSizeId pageSizeId)
QSizeF	size(QPageSize::PageSizeId pageSizeId, QPageSize::Unit units)
QSize	sizePixels(QPageSize::PageSizeId pageSizeId, int resolution)
QSize	sizePoints(QPageSize::PageSizeId pageSizeId)
int	windowsId(QPageSize::PageSizeId pageSizeId)

bool	operator!=(const QPageSize &lhs, const QPageSize &rhs)
bool	operator==(const QPageSize &lhs, const QPageSize &rhs)

Ausführliche Beschreibung

Diese Klasse implementiert die Unterstützung für die im Adobe PostScript PPD-Standard v4.3 definierten Standardseitengrößen. Sie definiert den Standardsatz an Seitengrößen in Punkten, Millimetern und Zoll und stellt sicher, dass diese Größen konsistent verwendet werden. Andere Maßeinheiten können verwendet werden, werden jedoch berechnet und sind daher möglicherweise nicht immer konsistent. Die definierten Punktgrößen sind immer ganze Zahlen, alle anderen Größen können Bruchteile einer Einheit sein.

Die definierte Größe wird immer in der Reihenfolge Breite × Höhe angegeben, ohne dass eine Seitenausrichtung impliziert wird. Beachten Sie, dass es möglich ist, Seitenformate zu definieren, bei denen die Breite größer ist als die Höhe, wie z. B. „ QPageSize::Ledger “; daher können Sie sich nicht darauf verlassen, die Breiten- und Höhenwerte zu vergleichen, um die Seitenausrichtung zu bestimmen.

Beispielsweise ist A4 durch den Standard als 210 mm × 297 mm, 8,27 Zoll × 11,69 Zoll oder 595 pt × 842 pt definiert.

Sie können auch benutzerdefinierte Seitengrößen mit beliebigen Namen in beliebigen Einheiten festlegen; diese Einheitengröße wird beibehalten und als Grundlage für alle weiteren Berechnungen der Einheitengröße verwendet.

Wenn Sie eine `QPageSize` mithilfe eines benutzerdefinierten ` QSize ` erstellen, können Sie festlegen, ob `QPageSize` versuchen soll, die Größe an eine Standardseitengröße anzupassen. Standardmäßig verwendet `QPaperSize` den Modus „ FuzzyMatch “, bei dem eine angegebene Seitengröße an eine Standardseitengröße angepasst wird, sofern sie innerhalb von 3 PostScript-Punkten einer definierten Standardgröße liegt. Sie können dies überschreiben, um nur eine exakte Übereinstimmung zu verlangen; dies wird jedoch nicht empfohlen, da bei Umrechnungen zwischen Einheiten leicht 3 Punkte verloren gehen können, was zu falschen Seitengrößen führt.

Eine „QPageSize“-Instanz kann auch durch Abfrage der unterstützten Seitengrößen für ein Druckgerät abgerufen werden. In diesem Fall ist der zurückgegebene lokalisierte Name derjenige, der vom Drucker selbst definiert wurde. Beachten Sie, dass das Druckgerät die aktuelle Standardsprache möglicherweise nicht unterstützt.

Die Klasse bietet außerdem Komfortmethoden zur Konvertierung von Seitengrößen-IDs in verschiedene Einheitgrößen und umgekehrt.

Siehe auch QPagedPaintDevice und QPdfWriter.

Dokumentation zu Mitgliedstypen

enum QPageSize::PageSizeId

Dieser Enum-Typ listet die verfügbaren Seitengrößen auf, wie sie im Postscript-PPD-Standard definiert sind. Diese Werte sind auch unter QPagedPaintDevice und QPrinter aufgeführt.

Die definierten Größen sind:

Konstante	Wert	Beschreibung
`QPageSize::A0`	`3`	841 x 1189 mm
`QPageSize::A1`	`4`	594 × 841 mm
`QPageSize::A2`	`5`	420 × 594 mm
`QPageSize::A3`	`6`	297 × 420 mm
`QPageSize::A4`	`7`	210 × 297 mm, 8,26 × 11,69 Zoll
`QPageSize::A5`	`8`	148 × 210 mm
`QPageSize::A6`	`9`	105 × 148 mm
`QPageSize::A7`	`10`	74 × 105 mm
`QPageSize::A8`	`11`	52 × 74 mm
`QPageSize::A9`	`12`	37 × 52 mm
`QPageSize::B0`	`14`	1000 × 1414 mm
`QPageSize::B1`	`15`	707 × 1000 mm
`QPageSize::B2`	`16`	500 × 707 mm
`QPageSize::B3`	`17`	353 × 500 mm
`QPageSize::B4`	`18`	250 × 353 mm
`QPageSize::B5`	`19`	176 x 250 mm, 6,93 x 9,84 Zoll
`QPageSize::B6`	`20`	125 × 176 mm
`QPageSize::B7`	`21`	88 × 125 mm
`QPageSize::B8`	`22`	62 × 88 mm
`QPageSize::B9`	`23`	44 × 62 mm
`QPageSize::B10`	`24`	31 x 44 mm
`QPageSize::C5E`	`25`	163 × 229 mm
`QPageSize::Comm10E`	`26`	105 x 241 mm, US-Standard-Umschlag „10“
`QPageSize::DLE`	`27`	110 × 220 mm
`QPageSize::Executive`	`2`	7,5 x 10 Zoll, 190,5 x 254 mm
`QPageSize::Folio`	`28`	210 × 330 mm
`QPageSize::Ledger`	`29`	431,8 x 279,4 mm
`QPageSize::Legal`	`1`	8,5 x 14 Zoll, 215,9 x 355,6 mm
`QPageSize::Letter`	`0`	8,5 x 11 Zoll, 215,9 x 279,4 mm
`QPageSize::Tabloid`	`30`	279,4 x 431,8 mm
`QPageSize::Custom`	`31`	Unbekannt oder eine benutzerdefinierte Größe.
`QPageSize::A10`	`13`
`QPageSize::A3Extra`	`32`
`QPageSize::A4Extra`	`33`
`QPageSize::A4Plus`	`34`
`QPageSize::A4Small`	`35`
`QPageSize::A5Extra`	`36`
`QPageSize::B5Extra`	`37`
`QPageSize::JisB0`	`38`
`QPageSize::JisB1`	`39`
`QPageSize::JisB2`	`40`
`QPageSize::JisB3`	`41`
`QPageSize::JisB4`	`42`
`QPageSize::JisB5`	`43`
`QPageSize::JisB6`	`44`	,
`QPageSize::JisB7`	`45`
`QPageSize::JisB8`	`46`
`QPageSize::JisB9`	`47`
`QPageSize::JisB10`	`48`
`QPageSize::AnsiA`	`Letter`	= Brief
`QPageSize::AnsiB`	`Ledger`	= Hauptbuch
`QPageSize::AnsiC`	`49`
`QPageSize::AnsiD`	`50`
`QPageSize::AnsiE`	`51`
`QPageSize::LegalExtra`	`52`
`QPageSize::LetterExtra`	`53`
`QPageSize::LetterPlus`	`54`
`QPageSize::LetterSmall`	`55`
`QPageSize::TabloidExtra`	`56`
`QPageSize::ArchA`	`57`
`QPageSize::ArchB`	`58`
`QPageSize::ArchC`	`59`
`QPageSize::ArchD`	`60`
`QPageSize::ArchE`	`61`
`QPageSize::Imperial7x9`	`62`
`QPageSize::Imperial8x10`	`63`
`QPageSize::Imperial9x11`	`64`
`QPageSize::Imperial9x12`	`65`
`QPageSize::Imperial10x11`	`66`
`QPageSize::Imperial10x13`	`67`
`QPageSize::Imperial10x14`	`68`
`QPageSize::Imperial12x11`	`69`
`QPageSize::Imperial15x11`	`70`
`QPageSize::ExecutiveStandard`	`71`
`QPageSize::Note`	`72`
`QPageSize::Quarto`	`73`
`QPageSize::Statement`	`74`
`QPageSize::SuperA`	`75`
`QPageSize::SuperB`	`76`
`QPageSize::Postcard`	`77`
`QPageSize::DoublePostcard`	`78`
`QPageSize::Prc16K`	`79`
`QPageSize::Prc32K`	`80`
`QPageSize::Prc32KBig`	`81`
`QPageSize::FanFoldUS`	`82`
`QPageSize::FanFoldGerman`	`83`
`QPageSize::FanFoldGermanLegal`	`84`
`QPageSize::EnvelopeB4`	`85`
`QPageSize::EnvelopeB5`	`86`
`QPageSize::EnvelopeB6`	`87`
`QPageSize::EnvelopeC0`	`88`
`QPageSize::EnvelopeC1`	`89`
`QPageSize::EnvelopeC2`	`90`
`QPageSize::EnvelopeC3`	`91`
`QPageSize::EnvelopeC4`	`92`
`QPageSize::EnvelopeC5`	`C5E`	= C5E
`QPageSize::EnvelopeC6`	`93`
`QPageSize::EnvelopeC65`	`94`
`QPageSize::EnvelopeC7`	`95`
`QPageSize::EnvelopeDL`	`DLE`	= DLE
`QPageSize::Envelope9`	`96`
`QPageSize::Envelope10`	`Comm10E`	= Comm10E
`QPageSize::Envelope11`	`97`
`QPageSize::Envelope12`	`98`
`QPageSize::Envelope14`	`99`
`QPageSize::EnvelopeMonarch`	`100`
`QPageSize::EnvelopePersonal`	`101`
`QPageSize::EnvelopeChou3`	`102`
`QPageSize::EnvelopeChou4`	`103`
`QPageSize::EnvelopeInvite`	`104`
`QPageSize::EnvelopeItalian`	`105`
`QPageSize::EnvelopeKaku2`	`106`
`QPageSize::EnvelopeKaku3`	`107`
`QPageSize::EnvelopePrc1`	`108`
`QPageSize::EnvelopePrc2`	`109`
`QPageSize::EnvelopePrc3`	`110`
`QPageSize::EnvelopePrc4`	`111`
`QPageSize::EnvelopePrc5`	`112`
`QPageSize::EnvelopePrc6`	`113`
`QPageSize::EnvelopePrc7`	`114`
`QPageSize::EnvelopePrc8`	`115`
`QPageSize::EnvelopePrc9`	`116`
`QPageSize::EnvelopePrc10`	`117`
`QPageSize::EnvelopeYou4`	`118`
`QPageSize::LastPageSize`	`EnvelopeYou4`	= EnvelopeYou4

Aus historischen Gründen entspricht QPageSize::Executive nicht der Standardgröße „Executive“ in PostScript und Windows; verwenden Sie stattdessen QPageSize::ExecutiveStandard.

Die PostScript-Standardgröße QPageSize::Folio weicht von der Windows-Größe DMPAPER_FOLIO ab; verwenden Sie bei Bedarf die PostScript-Standardgröße QPageSize::FanFoldGermanLegal.

enum QPageSize::SizeMatchPolicy

Konstante	Wert	Beschreibung
`QPageSize::FuzzyMatch`	`0`	An eine Standardseitengröße anpassen, sofern die Toleranzgrenzen eingehalten werden.
`QPageSize::FuzzyOrientationMatch`	`1`	An eine Standardseitengröße anpassen, sofern die Toleranzgrenze eingehalten wird, unabhängig von der Ausrichtung.
`QPageSize::ExactMatch`	`2`	Nur dann an eine Standardseitengröße anpassen, wenn die Maße exakt übereinstimmen.

enum QPageSize::Unit

Dieser Enum-Typ dient zur Angabe der Maßeinheit für Seitengrößen.

Konstante	Wert	Beschreibung
`QPageSize::Millimeter`	`0`
`QPageSize::Point`	`1`	1/72 Zoll
`QPageSize::Inch`	`2`
`QPageSize::Pica`	`3`	1/72 eines Fußes, 1/6 eines Zolls, 12 Punkte
`QPageSize::Didot`	`4`	1/72 eines französischen Zolls, 0,375 mm
`QPageSize::Cicero`	`5`	1/6 eines französischen Zolls, 12 Didot, 4,5 mm

Dokumentation der Member-Funktionen

QPageSize::QPageSize()

Erzeugt einen Nullwert für „QPageSize“.

QPageSize::QPageSize(QPageSize::PageSizeId pageSize)

Erzeugt ein `QPageSize` mit der Standardgröße ` pageSize`.

Wenn „ pageSize “ den Wert „ QPageSize::Custom “ hat, ist die resultierende „QPageSize“ ungültig. Verwenden Sie stattdessen den Konstruktor für benutzerdefinierte Größen.

`[explicit]` QPageSize::QPageSize(const QSize &pointSize, const QString &name = QString(), QPageSize::SizeMatchPolicy matchPolicy = FuzzyMatch)

Erzeugt eine `QPageSize` der angegebenen ` pointSize ` in Punkten unter Verwendung der entsprechenden ` matchPolicy`.

Wenn die angegebene „ pointSize “ mit einer Standard-„ QPageSize::PageSizeId “ übereinstimmt, wird diese Seitengröße verwendet. Beachten Sie, dass, wenn die „ matchPolicy “ den Wert „ FuzzyMatch “ hat, dies dazu führen kann, dass die „ pointSize “ an die Standardgröße angepasst wird. Um dies zu verhindern, verwenden Sie stattdessen eine „ matchPolicy “ mit dem Wert „ ExactMatch “.

Wenn die angegebene „ pointSize “ keine Standard- QPageSize::PageSizeId ist, wird eine „ QPageSize::Custom “-Größe erstellt.

Ist name null, wird der standardmäßige lokalisierte Name verwendet. Bei einer benutzerdefinierten Seitengröße wird ein benutzerdefinierter Name im Format „Benutzerdefiniert (Breite x Höhe)“ erstellt.

Die Standard- matchPolicy lautet „ FuzzyMatch “.

`[explicit]` QPageSize::QPageSize(const QSizeF &size, QPageSize::Unit units, const QString &name = QString(), QPageSize::SizeMatchPolicy matchPolicy = FuzzyMatch)

Erstellt eine benutzerdefinierte Seite mit der angegebenen URL size unter units.

Wenn die angegebene „ size “ mit einer Standard-„ QPageSize::PageSizeId “ übereinstimmt, wird die Größe dieser Seite verwendet. Beachten Sie: Wenn die „ matchPolicy “ „ FuzzyMatch “ lautet, kann dies dazu führen, dass die „ size “ an die Standardgröße angepasst wird. Um dies zu verhindern, verwenden Sie stattdessen eine „ matchPolicy “ von „ ExactMatch “.

Wenn die angegebene „ size “ kein Standard- QPageSize::PageSizeId ist, wird eine „ QPageSize::Custom “-Größe erstellt. Die ursprüngliche Einheitsgröße bleibt erhalten und dient als Grundlage für alle weiteren Berechnungen der Einheitsgröße.

Ist „ name “ null, wird ein benutzerdefinierter Name in der Form „Benutzerdefiniert (Breite x Höhe)“ erstellt, wobei die Größe in den angegebenen Einheiten ausgedrückt wird.

QPageSize::QPageSize(const QPageSize &other)

Kopierkonstruktor, kopiert „ other “ in „this“.

`[noexcept]` QPageSize::~QPageSize()

Löscht die Seite.

QSizeF QPageSize::definitionSize() const

Gibt die definierte Größe des Seitenformats zurück.

Bei einer Standardseitengröße entspricht dies der in der jeweiligen Norm definierten Größe, d. h. ISO A4 wird in Millimetern angegeben, während ANSI Letter in Zoll angegeben wird.

Bei einer benutzerdefinierten Seitengröße entspricht dies der Originalgröße, die zur Erstellung des Seitengrößenobjekts verwendet wurde.

Ist die „ QPageSize “ ungültig, ist auch die „ QSizeF “ ungültig.

Siehe auch definitionUnits().

`[static]` QSizeF QPageSize::definitionSize(QPageSize::PageSizeId pageSizeId)

Gibt die Definitionsgröße des Standard- pageSizeId s zurück.

Um die Definitionseinheiten zu ermitteln, rufen Sie „ QPageSize::definitionUnits()“ auf.

QPageSize::Unit QPageSize::definitionUnits() const

Gibt die Definitionseinheiten der Seitengröße zurück.

Bei einer Standardseitengröße handelt es sich dabei um die in der jeweiligen Norm definierten Einheiten, d. h. ISO A4 wird in Millimetern definiert, während ANSI Letter in Zoll definiert wird.

Bei einer benutzerdefinierten Seitengröße handelt es sich um die ursprünglichen Einheiten, die zur Erstellung des Seitengrößenobjekts verwendet wurden.

Ist die Funktion „ QPageSize “ ungültig, ist auch die Funktion „ QPageSize::Unit “ ungültig.

Siehe auch ` definitionSize()`.

`[static]` QPageSize::Unit QPageSize::definitionUnits(QPageSize::PageSizeId pageSizeId)

Gibt die Definitionseinheiten der Standard pageSizeId zurück.

Um die Definitionsgröße zu ermitteln, rufen Sie „ QPageSize::definitionSize()“ auf.

QPageSize::PageSizeId QPageSize::id() const

Gibt die Standard- QPageSize::PageSizeId -Adresse der Seite zurück oder QPageSize::Custom.

Ist die „ QPageSize “ ungültig, lautet die ID „ QPageSize::Custom “.

`[static]` QPageSize::PageSizeId QPageSize::id(int windowsId)

Gibt den „ PageSizeId “ für den angegebenen Windows-DMPAPER-Enum-Wert „ windowsId “ zurück.

Wenn kein passender „ PageSizeId “ vorhanden ist, wird „ QPageSize::Custom “ zurückgegeben.

`[static]` QPageSize::PageSizeId QPageSize::id(const QSize &pointSize, QPageSize::SizeMatchPolicy matchPolicy = FuzzyMatch)

Gibt die Standard- QPageSize::PageSizeId des angegebenen pointSize in Punkten unter Verwendung des angegebenen matchPolicy zurück.

Bei Verwendung von „ FuzzyMatch “ stimmt die Punktgröße des zurückgegebenen „ PageSizeId “ möglicherweise nicht genau mit dem übergebenen „ pointSize “ überein. Sie sollten „ QPageSize::sizePoints()“ mit dem zurückgegebenen „ PageSizeId “ aufrufen, um die tatsächliche Punktgröße des „ PageSizeId “ zu ermitteln, bevor Sie es für Berechnungen verwenden.

`[static]` QPageSize::PageSizeId QPageSize::id(const QSizeF &size, QPageSize::Unit units, QPageSize::SizeMatchPolicy matchPolicy = FuzzyMatch)

Gibt die Standard- QPageSize::PageSizeId des angegebenen „ size “ in „ units “ unter Verwendung des angegebenen „ matchPolicy “ zurück.

Bei Verwendung von „ FuzzyMatch “ stimmt die Einheitsgröße des zurückgegebenen „ PageSizeId “ möglicherweise nicht genau mit dem von Ihnen übergebenen „ size “ überein. Sie sollten „ QPageSize::size()“ mit dem zurückgegebenen „ PageSizeId “ aufrufen, um die tatsächliche Einheitsgröße des „ PageSizeId “ zu ermitteln, bevor Sie es in Berechnungen verwenden.

bool QPageSize::isEquivalentTo(const QPageSize &other) const

Gibt „ true “ zurück, wenn diese Seite mit der Seite „ other “ identisch ist, d. h., wenn die Seite unabhängig von anderen Attributen wie dem Namen dieselbe Größe hat.

bool QPageSize::isValid() const

Gibt „ true “ zurück, wenn diese Seitengröße gültig ist.

Die Seitengröße kann ungültig sein, wenn sie mit einem ungültigen ` PageSizeId`, einem negativen oder ungültigen ` QSize ` oder ` QSizeF` oder dem Null-Konstruktor erstellt wurde.

QString QPageSize::key() const

Gibt den eindeutigen Schlüssel der Seitengröße zurück.

Standardmäßig ist dies das PPD-Standard-Schlüsselwort „mediaOption“ für das Seitenformat oder der benutzerdefinierte PPD-Formatschlüssel. Wenn die „ QPageSize “-Instanz von einem Druckgerät abgerufen wurde, handelt es sich um den vom Druckgerät bereitgestellten Schlüssel, der vom Standardschlüssel abweichen kann.

Ist die „ QPageSize “-Instanz ungültig, ist der Schlüssel eine leere Zeichenfolge.

Dieser Schlüssel sollte Endbenutzern niemals angezeigt werden, da es sich um einen rein internen Schlüssel handelt. Verwenden Sie für einen für Menschen lesbaren Namen die Funktion ` name()`.

Siehe auch ` name()`.

`[static]` QString QPageSize::key(QPageSize::PageSizeId pageSizeId)

Gibt das PPD-Schlüsselwort „mediaOption“ des Standard- pageSizeId s zurück.

Ist die „ QPageSize “ ungültig, ist das Schlüsselwort leer.

QString QPageSize::name() const

Gibt einen lokalisierten, für Menschen lesbaren Namen für die Seitengröße zurück.

Wenn die ` QPageSize `-Instanz von einem Druckgerät abgerufen wurde, wird der vom Druckgerät bereitgestellte Name verwendet. Beachten Sie, dass ein Druckgerät die aktuelle Standardsprache möglicherweise nicht unterstützt.

Ist die ` QPageSize ` ungültig, ist der Name eine leere Zeichenkette.

`[static]` QString QPageSize::name(QPageSize::PageSizeId pageSizeId)

Gibt den lokalisierten Namen des Standard- pageSizeId s zurück.

Ist die „ QPageSize “ ungültig, ist der Name leer.

QRectF QPageSize::rect(QPageSize::Unit units) const

Gibt das Seitenrechteck im gewünschten Format „ units “ zurück.

Ist der „ QPageSize “ ungültig, ist auch der „ QRect “ ungültig.

QRect QPageSize::rectPixels(int resolution) const

Gibt das Seitenrechteck in Gerätepixeln an der angegebenen Koordinate „ resolution “ zurück.

Ist der „ QPageSize “ ungültig, ist auch der „ QRect “ ungültig.

QRect QPageSize::rectPoints() const

Gibt das Seitenrechteck in Postscript-Punkten (1/72 Zoll) zurück.

Ist die „ QPageSize “ ungültig, ist auch die „ QRect “ ungültig.

QSizeF QPageSize::size(QPageSize::Unit units) const

Gibt die Größe der Seite im angegebenen „ units “ zurück.

Ist die ` QPageSize ` ungültig, ist auch die ` QSizeF ` ungültig.

`[static]` QSizeF QPageSize::size(QPageSize::PageSizeId pageSizeId, QPageSize::Unit units)

Gibt die Größe des Standard- pageSizeId s im angeforderten units zurück.

QSize QPageSize::sizePixels(int resolution) const

Gibt die Größe der Seite in Gerätepixel an der angegebenen Adresse „ resolution “ zurück.

Ist die „ QPageSize “ ungültig, ist auch die „ QSize “ ungültig.

`[static]` QSize QPageSize::sizePixels(QPageSize::PageSizeId pageSizeId, int resolution)

Gibt die Größe des Standard- pageSizeId s in Gerätepixeln für die angegebene resolution zurück.

QSize QPageSize::sizePoints() const

Gibt die Größe der Seite in Postscript-Punkten (1/72 Zoll) zurück.

Ist die „ QPageSize “ ungültig, ist auch die „ QSize “ ungültig.

`[static]` QSize QPageSize::sizePoints(QPageSize::PageSizeId pageSizeId)

Gibt die Größe der Standard pageSizeId e in Punkten zurück.

`[noexcept]` void QPageSize::swap(QPageSize &other)

Ersetzt diese URL QPageSize durch other. Dieser Vorgang ist sehr schnell und schlägt niemals fehl.

int QPageSize::windowsId() const

Gibt den Windows-DMPAPER-Enum-Wert für die Seitengröße zurück.

Nicht alle gültigen PPD-Seitengrößen haben ein Windows-Äquivalent; in diesem Fall wird 0 zurückgegeben.

Ist die „ QPageSize “ ungültig, beträgt die Windows-ID 0.

Siehe auch id().

`[static]` int QPageSize::windowsId(QPageSize::PageSizeId pageSizeId)

Gibt den Windows-DMPAPER-Enum-Wert des Standardformats „ pageSizeId “ zurück.

Nicht alle gültigen PPD-Seitengrößen haben ein Windows-Äquivalent; in diesem Fall wird 0 zurückgegeben.

`[noexcept]` QPageSize &QPageSize::operator=(QPageSize &&other)

Mit „Move-assigns“ wird „ other “ dieser Instanz von „ QPageSize “ zugewiesen, wodurch das Eigentumsrecht an dem verwalteten Zeiger auf diese Instanz übertragen wird.

QPageSize &QPageSize::operator=(const QPageSize &other)

Zuweisungsoperator, weist „ other “ der Variablen „this“ zu.