mirror of https://github.com/qt/qtbase.git
1880 lines
79 KiB
C++
1880 lines
79 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2014 John Layt <jlayt@kde.org>
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the QtGui module of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU Lesser General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU Lesser
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.LGPL3 included in the
|
|
** packaging of this file. Please review the following information to
|
|
** ensure the GNU Lesser General Public License version 3 requirements
|
|
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 2.0 or (at your option) the GNU General
|
|
** Public license version 3 or any later version approved by the KDE Free
|
|
** Qt Foundation. The licenses are as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
|
|
** https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include "qpagesize.h"
|
|
|
|
#include <QtCore/qcoreapplication.h>
|
|
#include <QtCore/qdebug.h>
|
|
#include <QtCore/qpoint.h>
|
|
#include <QtCore/qrect.h>
|
|
#include <QtCore/qsize.h>
|
|
#include <QtCore/qstring.h>
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
// Define the Windows DMPAPER sizes for use in the look-up table
|
|
// See http://msdn.microsoft.com/en-us/library/windows/desktop/dd319099.aspx
|
|
|
|
enum WindowsDmPaper {
|
|
DMPAPER_NONE = 0, // Not a DMPAPER, use for sizes without a DMPAPER value
|
|
DMPAPER_LETTER = 1,
|
|
DMPAPER_LETTERSMALL = 2,
|
|
DMPAPER_TABLOID = 3,
|
|
DMPAPER_LEDGER = 4,
|
|
DMPAPER_LEGAL = 5,
|
|
DMPAPER_STATEMENT = 6,
|
|
DMPAPER_EXECUTIVE = 7,
|
|
DMPAPER_A3 = 8,
|
|
DMPAPER_A4 = 9,
|
|
DMPAPER_A4SMALL = 10,
|
|
DMPAPER_A5 = 11,
|
|
DMPAPER_B4 = 12,
|
|
DMPAPER_B5 = 13,
|
|
DMPAPER_FOLIO = 14,
|
|
DMPAPER_QUARTO = 15,
|
|
DMPAPER_10X14 = 16,
|
|
DMPAPER_11X17 = 17,
|
|
DMPAPER_NOTE = 18,
|
|
DMPAPER_ENV_9 = 19,
|
|
DMPAPER_ENV_10 = 20,
|
|
DMPAPER_ENV_11 = 21,
|
|
DMPAPER_ENV_12 = 22,
|
|
DMPAPER_ENV_14 = 23,
|
|
DMPAPER_CSHEET = 24,
|
|
DMPAPER_DSHEET = 25,
|
|
DMPAPER_ESHEET = 26,
|
|
DMPAPER_ENV_DL = 27,
|
|
DMPAPER_ENV_C5 = 28,
|
|
DMPAPER_ENV_C3 = 29,
|
|
DMPAPER_ENV_C4 = 30,
|
|
DMPAPER_ENV_C6 = 31,
|
|
DMPAPER_ENV_C65 = 32,
|
|
DMPAPER_ENV_B4 = 33,
|
|
DMPAPER_ENV_B5 = 34,
|
|
DMPAPER_ENV_B6 = 35,
|
|
DMPAPER_ENV_ITALY = 36,
|
|
DMPAPER_ENV_MONARCH = 37,
|
|
DMPAPER_ENV_PERSONAL = 38,
|
|
DMPAPER_FANFOLD_US = 39,
|
|
DMPAPER_FANFOLD_STD_GERMAN = 40,
|
|
DMPAPER_FANFOLD_LGL_GERMAN = 41,
|
|
DMPAPER_ISO_B4 = 42,
|
|
DMPAPER_JAPANESE_POSTCARD = 43,
|
|
DMPAPER_9X11 = 44,
|
|
DMPAPER_10X11 = 45,
|
|
DMPAPER_15X11 = 46,
|
|
DMPAPER_ENV_INVITE = 47,
|
|
DMPAPER_RESERVED_48 = 48,
|
|
DMPAPER_RESERVED_49 = 49,
|
|
DMPAPER_LETTER_EXTRA = 50,
|
|
DMPAPER_LEGAL_EXTRA = 51,
|
|
DMPAPER_TABLOID_EXTRA = 52,
|
|
DMPAPER_A4_EXTRA = 53,
|
|
DMPAPER_LETTER_TRANSVERSE = 54,
|
|
DMPAPER_A4_TRANSVERSE = 55,
|
|
DMPAPER_LETTER_EXTRA_TRANSVERSE = 56,
|
|
DMPAPER_A_PLUS = 57,
|
|
DMPAPER_B_PLUS = 58,
|
|
DMPAPER_LETTER_PLUS = 59,
|
|
DMPAPER_A4_PLUS = 60,
|
|
DMPAPER_A5_TRANSVERSE = 61,
|
|
DMPAPER_B5_TRANSVERSE = 62,
|
|
DMPAPER_A3_EXTRA = 63,
|
|
DMPAPER_A5_EXTRA = 64,
|
|
DMPAPER_B5_EXTRA = 65,
|
|
DMPAPER_A2 = 66,
|
|
DMPAPER_A3_TRANSVERSE = 67,
|
|
DMPAPER_A3_EXTRA_TRANSVERSE = 68,
|
|
DMPAPER_DBL_JAPANESE_POSTCARD = 69,
|
|
DMPAPER_A6 = 70,
|
|
DMPAPER_JENV_KAKU2 = 71,
|
|
DMPAPER_JENV_KAKU3 = 72,
|
|
DMPAPER_JENV_CHOU3 = 73,
|
|
DMPAPER_JENV_CHOU4 = 74,
|
|
DMPAPER_LETTER_ROTATED = 75,
|
|
DMPAPER_A3_ROTATED = 76,
|
|
DMPAPER_A4_ROTATED = 77,
|
|
DMPAPER_A5_ROTATED = 78,
|
|
DMPAPER_B4_JIS_ROTATED = 79,
|
|
DMPAPER_B5_JIS_ROTATED = 80,
|
|
DMPAPER_JAPANESE_POSTCARD_ROTATED = 81,
|
|
DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED = 82,
|
|
DMPAPER_A6_ROTATED = 83,
|
|
DMPAPER_JENV_KAKU2_ROTATED = 84,
|
|
DMPAPER_JENV_KAKU3_ROTATED = 85,
|
|
DMPAPER_JENV_CHOU3_ROTATED = 86,
|
|
DMPAPER_JENV_CHOU4_ROTATED = 87,
|
|
DMPAPER_B6_JIS = 88,
|
|
DMPAPER_B6_JIS_ROTATED = 89,
|
|
DMPAPER_12X11 = 90,
|
|
DMPAPER_JENV_YOU4 = 91,
|
|
DMPAPER_JENV_YOU4_ROTATED = 92,
|
|
DMPAPER_P16K = 93,
|
|
DMPAPER_P32K = 94,
|
|
DMPAPER_P32KBIG = 95,
|
|
DMPAPER_PENV_1 = 96,
|
|
DMPAPER_PENV_2 = 97,
|
|
DMPAPER_PENV_3 = 98,
|
|
DMPAPER_PENV_4 = 99,
|
|
DMPAPER_PENV_5 = 100,
|
|
DMPAPER_PENV_6 = 101,
|
|
DMPAPER_PENV_7 = 102,
|
|
DMPAPER_PENV_8 = 103,
|
|
DMPAPER_PENV_9 = 104,
|
|
DMPAPER_PENV_10 = 105,
|
|
DMPAPER_P16K_ROTATED = 106,
|
|
DMPAPER_P32K_ROTATED = 107,
|
|
DMPAPER_P32KBIG_ROTATED = 108,
|
|
DMPAPER_PENV_1_ROTATED = 109,
|
|
DMPAPER_PENV_2_ROTATED = 110,
|
|
DMPAPER_PENV_3_ROTATED = 111,
|
|
DMPAPER_PENV_4_ROTATED = 112,
|
|
DMPAPER_PENV_5_ROTATED = 113,
|
|
DMPAPER_PENV_6_ROTATED = 114,
|
|
DMPAPER_PENV_7_ROTATED = 115,
|
|
DMPAPER_PENV_8_ROTATED = 116,
|
|
DMPAPER_PENV_9_ROTATED = 117,
|
|
DMPAPER_PENV_10_ROTATED = 118,
|
|
DMPAPER_LAST = DMPAPER_PENV_10_ROTATED,
|
|
DMPAPER_USER = 256
|
|
};
|
|
|
|
// Conversion table for historic page size values that we don't support.
|
|
// These are deprecated in PPD and strongly discouraged from being used,
|
|
// so convert them to usable page sizes to support older print devices.
|
|
// The paper source orientation will be handled in the QPrintMedia class,
|
|
// we're only concerned about the standard size in QPageSize.
|
|
// _ROTATED = 90 degrees or QPageLayout::Landscape
|
|
// _TRANSVERSE = 180 degrees or QPageLayout::ReversePortrait
|
|
|
|
static const int qt_windowsConversion[][2] = {
|
|
{DMPAPER_11X17, DMPAPER_TABLOID}, // = DMPAPER_LEDGER rotated
|
|
{DMPAPER_A3_EXTRA_TRANSVERSE, DMPAPER_A3_EXTRA},
|
|
{DMPAPER_A3_ROTATED, DMPAPER_A3},
|
|
{DMPAPER_A3_TRANSVERSE, DMPAPER_A3},
|
|
{DMPAPER_A4_ROTATED, DMPAPER_A4},
|
|
{DMPAPER_A4_TRANSVERSE, DMPAPER_A4},
|
|
{DMPAPER_A5_ROTATED, DMPAPER_A5},
|
|
{DMPAPER_A5_TRANSVERSE, DMPAPER_A5},
|
|
{DMPAPER_A6_ROTATED, DMPAPER_A6},
|
|
{DMPAPER_B4_JIS_ROTATED, DMPAPER_B4},
|
|
{DMPAPER_B5_JIS_ROTATED, DMPAPER_B5},
|
|
{DMPAPER_B5_TRANSVERSE, DMPAPER_B5},
|
|
{DMPAPER_B6_JIS_ROTATED, DMPAPER_B6_JIS},
|
|
{DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED, DMPAPER_DBL_JAPANESE_POSTCARD},
|
|
{DMPAPER_JAPANESE_POSTCARD_ROTATED, DMPAPER_JAPANESE_POSTCARD},
|
|
{DMPAPER_JENV_CHOU3_ROTATED, DMPAPER_JENV_CHOU3},
|
|
{DMPAPER_JENV_CHOU4_ROTATED, DMPAPER_JENV_CHOU4},
|
|
{DMPAPER_JENV_KAKU2_ROTATED, DMPAPER_JENV_KAKU2},
|
|
{DMPAPER_JENV_KAKU3_ROTATED, DMPAPER_JENV_KAKU3},
|
|
{DMPAPER_JENV_YOU4_ROTATED, DMPAPER_JENV_YOU4},
|
|
{DMPAPER_LETTER_EXTRA_TRANSVERSE, DMPAPER_LETTER_EXTRA},
|
|
{DMPAPER_LETTER_ROTATED, DMPAPER_LETTER},
|
|
{DMPAPER_LETTER_TRANSVERSE, DMPAPER_LETTER},
|
|
{DMPAPER_P16K_ROTATED, DMPAPER_P16K},
|
|
{DMPAPER_P32K_ROTATED, DMPAPER_P32K},
|
|
{DMPAPER_P32KBIG_ROTATED, DMPAPER_P32KBIG},
|
|
{DMPAPER_PENV_1_ROTATED, DMPAPER_PENV_1},
|
|
{DMPAPER_PENV_2_ROTATED, DMPAPER_PENV_2},
|
|
{DMPAPER_PENV_3_ROTATED, DMPAPER_PENV_3},
|
|
{DMPAPER_PENV_4_ROTATED, DMPAPER_PENV_4},
|
|
{DMPAPER_PENV_5_ROTATED, DMPAPER_PENV_5},
|
|
{DMPAPER_PENV_6_ROTATED, DMPAPER_PENV_6},
|
|
{DMPAPER_PENV_7_ROTATED, DMPAPER_PENV_7},
|
|
{DMPAPER_PENV_8_ROTATED, DMPAPER_PENV_8},
|
|
{DMPAPER_PENV_9_ROTATED, DMPAPER_PENV_9},
|
|
{DMPAPER_PENV_10_ROTATED, DMPAPER_PENV_10} // Is = DMPAPER_LAST, use as loop terminator
|
|
};
|
|
|
|
static const int windowsConversionCount = int(sizeof(qt_windowsConversion) / sizeof(qt_windowsConversion[0]));
|
|
|
|
// Standard sizes data
|
|
struct StandardPageSize {
|
|
QPageSize::PageSizeId id;
|
|
int windowsId; // Windows DMPAPER value
|
|
QPageSize::Unit definitionUnits; // Standard definition size, e.g. ISO uses mm, ANSI uses inches
|
|
int widthPoints;
|
|
int heightPoints;
|
|
qreal widthMillimeters;
|
|
qreal heightMillimeters;
|
|
qreal widthInches;
|
|
qreal heightInches;
|
|
const char *mediaOption; // PPD standard mediaOption ID
|
|
};
|
|
|
|
// Standard page sizes taken from the Postscript PPD Standard v4.3
|
|
// See http://partners.adobe.com/public/developer/en/ps/5003.PPD_Spec_v4.3.pdf
|
|
// Excludes all Transverse and Rotated sizes
|
|
// NB! This table needs to be in sync with QPageSize::PageSizeId
|
|
static const StandardPageSize qt_pageSizes[] = {
|
|
|
|
// Existing Qt sizes including ISO, US, ANSI and other standards
|
|
{QPageSize::A4 , DMPAPER_A4 , QPageSize::Millimeter, 595, 842, 210 , 297 , 8.27, 11.69, "A4"},
|
|
{QPageSize::B5 , DMPAPER_NONE , QPageSize::Millimeter, 499, 709, 176 , 250 , 6.9 , 9.8 , "ISOB5"},
|
|
{QPageSize::Letter , DMPAPER_LETTER , QPageSize::Inch , 612, 792, 215.9, 279.4, 8.5 , 11 , "Letter"},
|
|
{QPageSize::Legal , DMPAPER_LEGAL , QPageSize::Inch , 612, 1008, 215.9, 355.6, 8.5 , 14 , "Legal"},
|
|
{QPageSize::Executive , DMPAPER_NONE , QPageSize::Inch , 540, 720, 190.5, 254 , 7.5 , 10 , "Executive.7.5x10in"}, // Qt size differs from Postscript / Windows
|
|
{QPageSize::A0 , DMPAPER_NONE , QPageSize::Millimeter, 2384, 3370, 841 , 1189 , 33.11, 46.81, "A0"},
|
|
{QPageSize::A1 , DMPAPER_NONE , QPageSize::Millimeter, 1684, 2384, 594 , 841 , 23.39, 33.11, "A1"},
|
|
{QPageSize::A2 , DMPAPER_A2 , QPageSize::Millimeter, 1191, 1684, 420 , 594 , 16.54, 23.39, "A2"},
|
|
{QPageSize::A3 , DMPAPER_A3 , QPageSize::Millimeter, 842, 1191, 297 , 420 , 11.69, 16.54, "A3"},
|
|
{QPageSize::A5 , DMPAPER_A5 , QPageSize::Millimeter, 420, 595, 148 , 210 , 5.83, 8.27, "A5"},
|
|
{QPageSize::A6 , DMPAPER_A6 , QPageSize::Millimeter, 297, 420, 105 , 148 , 4.13, 5.83, "A6"},
|
|
{QPageSize::A7 , DMPAPER_NONE , QPageSize::Millimeter, 210, 297, 74 , 105 , 2.91, 4.13, "A7"},
|
|
{QPageSize::A8 , DMPAPER_NONE , QPageSize::Millimeter, 148, 210, 52 , 74 , 2.05, 2.91, "A8"},
|
|
{QPageSize::A9 , DMPAPER_NONE , QPageSize::Millimeter, 105, 148, 37 , 52 , 1.46, 2.05, "A9"},
|
|
{QPageSize::B0 , DMPAPER_NONE , QPageSize::Millimeter, 2835, 4008, 1000 , 1414 , 39.37, 55.67, "ISOB0"},
|
|
{QPageSize::B1 , DMPAPER_NONE , QPageSize::Millimeter, 2004, 2835, 707 , 1000 , 27.83, 39.37, "ISOB1"},
|
|
{QPageSize::B10 , DMPAPER_NONE , QPageSize::Millimeter, 88, 125, 31 , 44 , 1.22, 1.73, "ISOB10"},
|
|
{QPageSize::B2 , DMPAPER_NONE , QPageSize::Millimeter, 1417, 2004, 500 , 707 , 19.68, 27.83, "ISOB2"},
|
|
{QPageSize::B3 , DMPAPER_NONE , QPageSize::Millimeter, 1001, 1417, 353 , 500 , 13.9 , 19.68, "ISOB3"},
|
|
{QPageSize::B4 , DMPAPER_ISO_B4 , QPageSize::Millimeter, 709, 1001, 250 , 353 , 9.84, 13.9 , "ISOB4"},
|
|
{QPageSize::B6 , DMPAPER_NONE , QPageSize::Millimeter, 354, 499, 125 , 176 , 4.92, 6.93, "ISOB6"},
|
|
{QPageSize::B7 , DMPAPER_NONE , QPageSize::Millimeter, 249, 354, 88 , 125 , 3.46, 4.92, "ISOB7"},
|
|
{QPageSize::B8 , DMPAPER_NONE , QPageSize::Millimeter, 176, 249, 62 , 88 , 2.44, 3.46, "ISOB8"},
|
|
{QPageSize::B9 , DMPAPER_NONE , QPageSize::Millimeter, 125, 176, 44 , 62 , 1.73, 2.44, "ISOB9"},
|
|
{QPageSize::C5E , DMPAPER_ENV_C5 , QPageSize::Millimeter, 459, 649, 162 , 229 , 6.38, 9.02, "EnvC5"},
|
|
{QPageSize::Comm10E , DMPAPER_ENV_10 , QPageSize::Inch , 297, 684, 104.8, 241.3, 4.12, 9.5 , "Env10"},
|
|
{QPageSize::DLE , DMPAPER_ENV_DL , QPageSize::Millimeter, 312, 624, 110 , 220 , 4.33, 8.66, "EnvDL"},
|
|
{QPageSize::Folio , DMPAPER_NONE , QPageSize::Millimeter, 595, 935, 210 , 330 , 8.27, 13 , "Folio"},
|
|
{QPageSize::Ledger , DMPAPER_LEDGER , QPageSize::Inch , 1224, 792, 431.8, 279.4, 17 , 11 , "Ledger"},
|
|
{QPageSize::Tabloid , DMPAPER_TABLOID , QPageSize::Inch , 792, 1224, 279.4, 431.8, 11 , 17 , "Tabloid"},
|
|
{QPageSize::Custom , DMPAPER_USER , QPageSize::Millimeter, -1, -1, -1. , -1 , -1 , -1 , "Custom"}, // Special case to keep in sync with QPageSize::PageSizeId
|
|
|
|
// ISO Standard Sizes
|
|
{QPageSize::A10 , DMPAPER_NONE , QPageSize::Millimeter, 73, 105, 26 , 37 , 1.02, 1.46, "A10"},
|
|
{QPageSize::A3Extra , DMPAPER_A3_EXTRA , QPageSize::Millimeter, 913, 1262, 322 , 445 , 12.67, 17.52, "A3Extra"},
|
|
{QPageSize::A4Extra , DMPAPER_A4_EXTRA , QPageSize::Millimeter, 667, 914, 235.5, 322.3, 9.27, 12.69, "A4Extra"},
|
|
{QPageSize::A4Plus , DMPAPER_A4_PLUS , QPageSize::Millimeter, 595, 936, 210 , 330 , 8.27, 13 , "A4Plus"},
|
|
{QPageSize::A4Small , DMPAPER_A4SMALL , QPageSize::Millimeter, 595, 842, 210 , 297 , 8.27, 11.69, "A4Small"},
|
|
{QPageSize::A5Extra , DMPAPER_A5_EXTRA , QPageSize::Millimeter, 492, 668, 174 , 235 , 6.85, 9.25, "A5Extra"},
|
|
{QPageSize::B5Extra , DMPAPER_B5_EXTRA , QPageSize::Millimeter, 570, 782, 201 , 276 , 7.9 , 10.8 , "ISOB5Extra"},
|
|
|
|
// JIS Standard Sizes
|
|
{QPageSize::JisB0 , DMPAPER_NONE , QPageSize::Millimeter, 2920, 4127, 1030 , 1456 , 40.55, 57.32, "B0"},
|
|
{QPageSize::JisB1 , DMPAPER_NONE , QPageSize::Millimeter, 2064, 2920, 728 , 1030 , 28.66, 40.55, "B1"},
|
|
{QPageSize::JisB2 , DMPAPER_NONE , QPageSize::Millimeter, 1460, 2064, 515 , 728 , 20.28, 28.66, "B2"},
|
|
{QPageSize::JisB3 , DMPAPER_NONE , QPageSize::Millimeter, 1032, 1460, 364 , 515 , 14.33, 20.28, "B3"},
|
|
{QPageSize::JisB4 , DMPAPER_B4 , QPageSize::Millimeter, 729, 1032, 257 , 364 , 10.12, 14.33, "B4"},
|
|
{QPageSize::JisB5 , DMPAPER_B5 , QPageSize::Millimeter, 516, 729, 182 , 257 , 7.17, 10.12, "B5"},
|
|
{QPageSize::JisB6 , DMPAPER_B6_JIS , QPageSize::Millimeter, 363, 516, 128 , 182 , 5.04, 7.17, "B6"},
|
|
{QPageSize::JisB7 , DMPAPER_NONE , QPageSize::Millimeter, 258, 363, 91 , 128 , 3.58, 5.04, "B7"},
|
|
{QPageSize::JisB8 , DMPAPER_NONE , QPageSize::Millimeter, 181, 258, 64 , 91 , 2.52, 3.58, "B8"},
|
|
{QPageSize::JisB9 , DMPAPER_NONE , QPageSize::Millimeter, 127, 181, 45 , 64 , 1.77, 2.52, "B9"},
|
|
{QPageSize::JisB10 , DMPAPER_NONE , QPageSize::Millimeter, 91, 127, 32 , 45 , 1.26, 1.77, "B10"},
|
|
|
|
// ANSI / US Standard sizes
|
|
{QPageSize::AnsiC , DMPAPER_NONE , QPageSize::Inch , 1224, 1584, 431.8, 558.8, 17 , 22 , "AnsiC"},
|
|
{QPageSize::AnsiD , DMPAPER_NONE , QPageSize::Inch , 1584, 2448, 558.8, 863.6, 22 , 34 , "AnsiD"},
|
|
{QPageSize::AnsiE , DMPAPER_NONE , QPageSize::Inch , 2448, 3168, 863.6, 1118 , 34 , 44 , "AnsiE"},
|
|
{QPageSize::LegalExtra , DMPAPER_LEGAL_EXTRA , QPageSize::Inch , 684, 1080, 241.3, 381 , 9.5 , 15 , "LegalExtra"},
|
|
{QPageSize::LetterExtra , DMPAPER_LETTER_EXTRA , QPageSize::Inch , 684, 864, 241.3, 304.8, 9.5 , 12 , "LetterExtra"},
|
|
{QPageSize::LetterPlus , DMPAPER_LETTER_PLUS , QPageSize::Inch , 612, 914, 215.9, 322.3, 8.5 , 12.69, "LetterPlus"},
|
|
{QPageSize::LetterSmall , DMPAPER_LETTERSMALL , QPageSize::Inch , 612, 792, 215.9, 279.4, 8.5 , 11 , "LetterSmall"},
|
|
{QPageSize::TabloidExtra , DMPAPER_TABLOID_EXTRA , QPageSize::Inch , 864, 1296, 304.8, 457.2, 12 , 18 , "TabloidExtra"},
|
|
|
|
// Architectural sizes
|
|
{QPageSize::ArchA , DMPAPER_NONE , QPageSize::Inch , 648, 864, 228.6, 304.8, 9 , 12 , "ARCHA"},
|
|
{QPageSize::ArchB , DMPAPER_NONE , QPageSize::Inch , 864, 1296, 304.8, 457.2, 12 , 18 , "ARCHB"},
|
|
{QPageSize::ArchC , DMPAPER_CSHEET , QPageSize::Inch , 1296, 1728, 457.2, 609.6, 18 , 24 , "ARCHC"},
|
|
{QPageSize::ArchD , DMPAPER_DSHEET , QPageSize::Inch , 1728, 2592, 609.6, 914.4, 24 , 36 , "ARCHD"},
|
|
{QPageSize::ArchE , DMPAPER_ESHEET , QPageSize::Inch , 2592, 3456, 914.4, 1219 , 36 , 48 , "ARCHE"},
|
|
|
|
// Inch-based Sizes
|
|
{QPageSize::Imperial7x9 , DMPAPER_NONE , QPageSize::Inch , 504, 648, 177.8, 228.6, 7 , 9 , "7x9"},
|
|
{QPageSize::Imperial8x10 , DMPAPER_NONE , QPageSize::Inch , 576, 720, 203.2, 254 , 8 , 10 , "8x10"},
|
|
{QPageSize::Imperial9x11 , DMPAPER_9X11 , QPageSize::Inch , 648, 792, 228.6, 279.4, 9 , 11 , "9x11"},
|
|
{QPageSize::Imperial9x12 , DMPAPER_NONE , QPageSize::Inch , 648, 864, 228.6, 304.8, 9 , 12 , "9x12"},
|
|
{QPageSize::Imperial10x11 , DMPAPER_10X11 , QPageSize::Inch , 720, 792, 254 , 279.4, 10 , 11 , "10x11"},
|
|
{QPageSize::Imperial10x13 , DMPAPER_NONE , QPageSize::Inch , 720, 936, 254 , 330.2, 10 , 13 , "10x13"},
|
|
{QPageSize::Imperial10x14 , DMPAPER_10X14 , QPageSize::Inch , 720, 1008, 254 , 355.6, 10 , 14 , "10x14"},
|
|
{QPageSize::Imperial12x11 , DMPAPER_12X11 , QPageSize::Inch , 864, 792, 304.8, 279.4, 12 , 11 , "12x11"},
|
|
{QPageSize::Imperial15x11 , DMPAPER_15X11 , QPageSize::Inch , 1080, 792, 381 , 279.4, 15 , 11 , "15x11"},
|
|
|
|
// Other Page Sizes
|
|
{QPageSize::ExecutiveStandard , DMPAPER_EXECUTIVE , QPageSize::Inch , 522, 756, 184.2, 266.7, 7.25, 10.5 , "Executive"}, // Qt size differs from Postscript / Windows
|
|
{QPageSize::Note , DMPAPER_NOTE , QPageSize::Inch , 612, 792, 215.9, 279.4, 8.5 , 11 , "Note"},
|
|
{QPageSize::Quarto , DMPAPER_QUARTO , QPageSize::Inch , 610, 780, 215.9, 275.1, 8.5 , 10.83, "Quarto"},
|
|
{QPageSize::Statement , DMPAPER_STATEMENT , QPageSize::Inch , 396, 612, 139.7, 215.9, 5.5 , 8.5 , "Statement"},
|
|
{QPageSize::SuperA , DMPAPER_A_PLUS , QPageSize::Millimeter, 643, 1009, 227 , 356 , 8.94, 14 , "SuperA"},
|
|
{QPageSize::SuperB , DMPAPER_B_PLUS , QPageSize::Millimeter, 864, 1380, 305 , 487 , 12 , 19.17, "SuperB"},
|
|
{QPageSize::Postcard , DMPAPER_JAPANESE_POSTCARD , QPageSize::Millimeter, 284, 419, 100 , 148 , 3.94, 5.83, "Postcard"},
|
|
{QPageSize::DoublePostcard , DMPAPER_DBL_JAPANESE_POSTCARD, QPageSize::Millimeter, 567, 419, 200 , 148 , 7.87, 5.83, "DoublePostcard"},
|
|
{QPageSize::Prc16K , DMPAPER_P16K , QPageSize::Millimeter, 414, 610, 146 , 215 , 5.75, 8.5 , "PRC16K"},
|
|
{QPageSize::Prc32K , DMPAPER_P32K , QPageSize::Millimeter, 275, 428, 97 , 151 , 3.82, 5.95, "PRC32K"},
|
|
{QPageSize::Prc32KBig , DMPAPER_P32KBIG , QPageSize::Millimeter, 275, 428, 97 , 151 , 3.82, 5.95, "PRC32KBig"},
|
|
|
|
// Fan Fold Sizes
|
|
{QPageSize::FanFoldUS , DMPAPER_FANFOLD_US , QPageSize::Inch , 1071, 792, 377.8, 279.4, 14.875, 11 , "FanFoldUS"},
|
|
{QPageSize::FanFoldGerman , DMPAPER_FANFOLD_STD_GERMAN , QPageSize::Inch , 612, 864, 215.9, 304.8, 8.5 , 12 , "FanFoldGerman"},
|
|
{QPageSize::FanFoldGermanLegal, DMPAPER_FANFOLD_LGL_GERMAN , QPageSize::Inch , 612, 936, 215.9, 330 , 8.5 , 13 , "FanFoldGermanLegal"},
|
|
|
|
// ISO Envelopes
|
|
{QPageSize::EnvelopeB4 , DMPAPER_ENV_B4 , QPageSize::Millimeter, 708, 1001, 250 , 353 , 9.84, 13.9 , "EnvISOB4"},
|
|
{QPageSize::EnvelopeB5 , DMPAPER_ENV_B5 , QPageSize::Millimeter, 499, 709, 176 , 250 , 6.9 , 9.8 , "EnvISOB5"},
|
|
{QPageSize::EnvelopeB6 , DMPAPER_ENV_B6 , QPageSize::Millimeter, 499, 354, 176 , 125 , 6.9 , 4.9 , "EnvISOB6"},
|
|
{QPageSize::EnvelopeC0 , DMPAPER_NONE , QPageSize::Millimeter, 2599, 3676, 917 , 1297 , 36.1 , 51.06, "EnvC0"},
|
|
{QPageSize::EnvelopeC1 , DMPAPER_NONE , QPageSize::Millimeter, 1837, 2599, 648 , 917 , 25.51, 36.1 , "EnvC1"},
|
|
{QPageSize::EnvelopeC2 , DMPAPER_NONE , QPageSize::Millimeter, 1298, 1837, 458 , 648 , 18.03, 25.51, "EnvC2"},
|
|
{QPageSize::EnvelopeC3 , DMPAPER_ENV_C3 , QPageSize::Millimeter, 918, 1296, 324 , 458 , 12.75, 18.03, "EnvC3"},
|
|
{QPageSize::EnvelopeC4 , DMPAPER_ENV_C4 , QPageSize::Millimeter, 649, 918, 229 , 324 , 9.02, 12.75, "EnvC4"},
|
|
{QPageSize::EnvelopeC6 , DMPAPER_ENV_C6 , QPageSize::Millimeter, 323, 459, 114 , 162 , 4.49, 6.38, "EnvC6"},
|
|
{QPageSize::EnvelopeC65 , DMPAPER_ENV_C65 , QPageSize::Millimeter, 324, 648, 114 , 229 , 4.5 , 9 , "EnvC65"},
|
|
{QPageSize::EnvelopeC7 , DMPAPER_NONE , QPageSize::Millimeter, 230, 323, 81 , 114 , 3.19, 4.49, "EnvC7"},
|
|
|
|
// US Envelopes
|
|
{QPageSize::Envelope9 , DMPAPER_ENV_9 , QPageSize::Inch , 279, 639, 98.4, 225.4, 3.875, 8.875, "Env9"},
|
|
{QPageSize::Envelope11 , DMPAPER_ENV_11 , QPageSize::Inch , 324, 747, 114.3, 263.5, 4.5 , 10.375, "Env11"},
|
|
{QPageSize::Envelope12 , DMPAPER_ENV_12 , QPageSize::Inch , 342, 792, 120.7, 279.4, 4.75, 11 , "Env12"},
|
|
{QPageSize::Envelope14 , DMPAPER_ENV_14 , QPageSize::Inch , 360, 828, 127 , 292.1, 5 , 11.5 , "Env14"},
|
|
{QPageSize::EnvelopeMonarch , DMPAPER_ENV_MONARCH , QPageSize::Inch , 279, 540, 98.43, 190.5, 3.875, 7.5 , "EnvMonarch"},
|
|
{QPageSize::EnvelopePersonal , DMPAPER_ENV_PERSONAL , QPageSize::Inch , 261, 468, 92.08, 165.1, 3.625, 6.5 , "EnvPersonal"},
|
|
|
|
// Other Envelopes
|
|
{QPageSize::EnvelopeChou3 , DMPAPER_JENV_CHOU3 , QPageSize::Millimeter, 340, 666, 120 , 235 , 4.72, 9.25, "EnvChou3"},
|
|
{QPageSize::EnvelopeChou4 , DMPAPER_JENV_CHOU4 , QPageSize::Millimeter, 255, 581, 90 , 205 , 3.54, 8 , "EnvChou4"},
|
|
{QPageSize::EnvelopeInvite , DMPAPER_ENV_INVITE , QPageSize::Millimeter, 624, 624, 220 , 220 , 8.66, 8.66, "EnvInvite"},
|
|
{QPageSize::EnvelopeItalian , DMPAPER_ENV_ITALY , QPageSize::Millimeter, 312, 652, 110 , 230 , 4.33, 9 , "EnvItalian"},
|
|
{QPageSize::EnvelopeKaku2 , DMPAPER_JENV_KAKU2 , QPageSize::Millimeter, 680, 941, 240 , 332 , 9.45, 13 , "EnvKaku2"},
|
|
{QPageSize::EnvelopeKaku3 , DMPAPER_JENV_KAKU3 , QPageSize::Millimeter, 612, 785, 216 , 277 , 8.5 , 10.9 , "EnvKaku3"},
|
|
{QPageSize::EnvelopePrc1 , DMPAPER_PENV_1 , QPageSize::Millimeter, 289, 468, 102 , 165 , 4 , 6.5 , "EnvPRC1"},
|
|
{QPageSize::EnvelopePrc2 , DMPAPER_PENV_2 , QPageSize::Millimeter, 289, 499, 102 , 176 , 4 , 6.9 , "EnvPRC2"},
|
|
{QPageSize::EnvelopePrc3 , DMPAPER_PENV_3 , QPageSize::Millimeter, 354, 499, 125 , 176 , 4.9 , 6.9 , "EnvPRC3"},
|
|
{QPageSize::EnvelopePrc4 , DMPAPER_PENV_4 , QPageSize::Millimeter, 312, 590, 110 , 208 , 4.33, 8.2 , "EnvPRC4"},
|
|
{QPageSize::EnvelopePrc5 , DMPAPER_PENV_5 , QPageSize::Millimeter, 312, 624, 110 , 220 , 4.33, 8.66, "EnvPRC5"},
|
|
{QPageSize::EnvelopePrc6 , DMPAPER_PENV_6 , QPageSize::Millimeter, 340, 652, 120 , 230 , 4.7 , 9 , "EnvPRC6"},
|
|
{QPageSize::EnvelopePrc7 , DMPAPER_PENV_7 , QPageSize::Millimeter, 454, 652, 160 , 230 , 6.3 , 9 , "EnvPRC7"},
|
|
{QPageSize::EnvelopePrc8 , DMPAPER_PENV_8 , QPageSize::Millimeter, 340, 876, 120 , 309 , 4.7 , 12.2 , "EnvPRC8"},
|
|
{QPageSize::EnvelopePrc9 , DMPAPER_PENV_9 , QPageSize::Millimeter, 649, 918, 229 , 324 , 9 , 12.75, "EnvPRC9"},
|
|
{QPageSize::EnvelopePrc10 , DMPAPER_PENV_10 , QPageSize::Millimeter, 918, 1298, 324 , 458 , 12.75, 18 , "EnvPRC10"},
|
|
{QPageSize::EnvelopeYou4 , DMPAPER_JENV_YOU4 , QPageSize::Millimeter, 298, 666, 105 , 235 , 4.13, 9.25, "EnvYou4"}
|
|
};
|
|
|
|
static const int pageSizesCount = int(sizeof(qt_pageSizes) / sizeof(qt_pageSizes[0]));
|
|
Q_STATIC_ASSERT(pageSizesCount == QPageSize::LastPageSize + 1);
|
|
|
|
// Return key name for PageSize
|
|
static QString qt_keyForPageSizeId(QPageSize::PageSizeId id)
|
|
{
|
|
return QString::fromLatin1(qt_pageSizes[id].mediaOption);
|
|
}
|
|
|
|
// Return id name for PPD Key
|
|
static QPageSize::PageSizeId qt_idForPpdKey(const QString &ppdKey, QSize *match = 0)
|
|
{
|
|
if (ppdKey.isEmpty())
|
|
return QPageSize::Custom;
|
|
QStringRef key(&ppdKey);
|
|
// Remove any Rotated or Tranverse modifiers
|
|
if (key.endsWith(QLatin1String("Rotated")))
|
|
key.chop(7);
|
|
else if (key.endsWith(QLatin1String(".Transverse")))
|
|
key.chop(11);
|
|
for (int i = 0; i <= int(QPageSize::LastPageSize); ++i) {
|
|
if (QLatin1String(qt_pageSizes[i].mediaOption) == key) {
|
|
if (match)
|
|
*match = QSize(qt_pageSizes[i].widthPoints, qt_pageSizes[i].heightPoints);
|
|
return qt_pageSizes[i].id;
|
|
}
|
|
}
|
|
return QPageSize::Custom;
|
|
}
|
|
|
|
// Return id name for Windows ID
|
|
static QPageSize::PageSizeId qt_idForWindowsID(int windowsId, QSize *match = 0)
|
|
{
|
|
// If outside known values then is Custom
|
|
if (windowsId <= DMPAPER_NONE || windowsId > DMPAPER_LAST)
|
|
return QPageSize::Custom;
|
|
// Check if one of the unsupported values, convert to valid value if is
|
|
for (int i = 0; i < windowsConversionCount; ++i) {
|
|
if (qt_windowsConversion[i][0] == windowsId) {
|
|
windowsId = qt_windowsConversion[i][1];
|
|
break;
|
|
}
|
|
}
|
|
// Look for the value in our supported size table
|
|
for (int i = 0; i <= int(QPageSize::LastPageSize); ++i) {
|
|
if (qt_pageSizes[i].windowsId == windowsId) {
|
|
if (match)
|
|
*match = QSize(qt_pageSizes[i].widthPoints, qt_pageSizes[i].heightPoints);
|
|
return qt_pageSizes[i].id;
|
|
}
|
|
}
|
|
// Otherwise is Custom
|
|
return QPageSize::Custom;
|
|
}
|
|
|
|
// Return key name for custom size
|
|
static QString qt_keyForCustomSize(const QSizeF &size, QPageSize::Unit units)
|
|
{
|
|
// PPD custom format
|
|
QString key = QStringLiteral("Custom.%1x%2%3");
|
|
QString abbrev;
|
|
switch (units) {
|
|
case QPageSize::Millimeter:
|
|
abbrev = QStringLiteral("mm");
|
|
break;
|
|
case QPageSize::Point:
|
|
break;
|
|
case QPageSize::Inch:
|
|
abbrev = QStringLiteral("in");
|
|
break;
|
|
case QPageSize::Pica:
|
|
abbrev = QStringLiteral("pc");
|
|
break;
|
|
case QPageSize::Didot:
|
|
abbrev = QStringLiteral("DD");
|
|
break;
|
|
case QPageSize::Cicero:
|
|
abbrev = QStringLiteral("CC");
|
|
break;
|
|
}
|
|
// Assumes size is already max 2 decimal places
|
|
return key.arg(size.width()).arg(size.height()).arg(abbrev);
|
|
}
|
|
|
|
// Return localized name for custom size
|
|
static QString qt_nameForCustomSize(const QSizeF &size, QPageSize::Unit units)
|
|
{
|
|
QString name;
|
|
switch (units) {
|
|
case QPageSize::Millimeter:
|
|
//: Custom size name in millimeters
|
|
name = QCoreApplication::translate("QPageSize", "Custom (%1mm x %2mm)");
|
|
break;
|
|
case QPageSize::Point:
|
|
//: Custom size name in points
|
|
name = QCoreApplication::translate("QPageSize", "Custom (%1pt x %2pt)");
|
|
break;
|
|
case QPageSize::Inch:
|
|
//: Custom size name in inches
|
|
name = QCoreApplication::translate("QPageSize", "Custom (%1in x %2in)");
|
|
break;
|
|
case QPageSize::Pica:
|
|
//: Custom size name in picas
|
|
name = QCoreApplication::translate("QPageSize", "Custom (%1pc x %2pc)");
|
|
break;
|
|
case QPageSize::Didot:
|
|
//: Custom size name in didots
|
|
name = QCoreApplication::translate("QPageSize", "Custom (%1DD x %2DD)");
|
|
break;
|
|
case QPageSize::Cicero:
|
|
//: Custom size name in ciceros
|
|
name = QCoreApplication::translate("QPageSize", "Custom (%1CC x %2CC)");
|
|
break;
|
|
}
|
|
// Assumes size is already max 2 decimal places
|
|
return name.arg(size.width()).arg(size.height());
|
|
}
|
|
|
|
// Multiplier for converting units to points.
|
|
static qreal qt_pointMultiplier(QPageSize::Unit unit)
|
|
{
|
|
switch (unit) {
|
|
case QPageSize::Millimeter:
|
|
return 2.83464566929;
|
|
case QPageSize::Point:
|
|
return 1.0;
|
|
case QPageSize::Inch:
|
|
return 72.0;
|
|
case QPageSize::Pica:
|
|
return 12;
|
|
case QPageSize::Didot:
|
|
return 1.065826771;
|
|
case QPageSize::Cicero:
|
|
return 12.789921252;
|
|
}
|
|
return 1.0;
|
|
}
|
|
|
|
// Multiplier for converting pixels to points.
|
|
Q_GUI_EXPORT qreal qt_pixelMultiplier(int resolution)
|
|
{
|
|
return resolution <= 0 ? 1.0 : 72.0 / resolution;
|
|
}
|
|
|
|
static QSizeF qt_definitionSize(QPageSize::PageSizeId pageSizeId)
|
|
{
|
|
QPageSize::Unit units = qt_pageSizes[pageSizeId].definitionUnits;
|
|
if (units == QPageSize::Millimeter)
|
|
return QSizeF(qt_pageSizes[pageSizeId].widthMillimeters, qt_pageSizes[pageSizeId].heightMillimeters);
|
|
Q_ASSERT(units == QPageSize::Inch); // We currently only support definitions in mm or inches
|
|
return QSizeF(qt_pageSizes[pageSizeId].widthInches, qt_pageSizes[pageSizeId].heightInches);
|
|
}
|
|
|
|
static QSizeF qt_convertUnits(const QSizeF &size, QPageSize::Unit fromUnits, QPageSize::Unit toUnits)
|
|
{
|
|
if (!size.isValid())
|
|
return QSizeF();
|
|
|
|
// If the units are the same or the size is 0, then don't need to convert
|
|
if (fromUnits == toUnits || (qFuzzyIsNull(size.width()) && qFuzzyIsNull(size.height())))
|
|
return size;
|
|
|
|
QSizeF newSize = size;
|
|
// First convert to points
|
|
if (fromUnits != QPageSize::Point) {
|
|
const qreal multiplier = qt_pointMultiplier(fromUnits);
|
|
newSize = newSize * multiplier;
|
|
}
|
|
// Then convert from points to required units
|
|
const qreal multiplier = qt_pointMultiplier(toUnits);
|
|
// Try force to 2 decimal places for consistency
|
|
const int width = qRound(newSize.width() * 100 / multiplier);
|
|
const int height = qRound(newSize.height() * 100 / multiplier);
|
|
return QSizeF(width / 100.0, height / 100.0);
|
|
}
|
|
|
|
static QSize qt_convertUnitsToPoints(const QSizeF &size, QPageSize::Unit units)
|
|
{
|
|
if (!size.isValid())
|
|
return QSize();
|
|
return QSizeF(size * qt_pointMultiplier(units)).toSize();
|
|
}
|
|
|
|
static QSize qt_convertPointsToPixels(const QSize &size, int resolution)
|
|
{
|
|
if (!size.isValid() || resolution <= 0)
|
|
return QSize();
|
|
const qreal multiplier = qt_pixelMultiplier(resolution);
|
|
return QSize(qRound(size.width() / multiplier), qRound(size.height() / multiplier));
|
|
}
|
|
|
|
static QSizeF qt_convertPointsToUnits(const QSize &size, QPageSize::Unit units)
|
|
{
|
|
if (!size.isValid())
|
|
return QSizeF();
|
|
const qreal multiplier = qt_pointMultiplier(units);
|
|
// Try force to 2 decimal places for consistency
|
|
const int width = qRound(size.width() * 100 / multiplier);
|
|
const int height = qRound(size.height() * 100 / multiplier);
|
|
return QSizeF(width / 100.0, height / 100.0);
|
|
}
|
|
|
|
static QSizeF qt_unitSize(QPageSize::PageSizeId pageSizeId, QPageSize::Unit units)
|
|
{
|
|
switch (units) {
|
|
case QPageSize::Millimeter:
|
|
return QSizeF(qt_pageSizes[pageSizeId].widthMillimeters, qt_pageSizes[pageSizeId].heightMillimeters);
|
|
case QPageSize::Point:
|
|
return QSizeF(qt_pageSizes[pageSizeId].widthPoints, qt_pageSizes[pageSizeId].heightPoints);
|
|
case QPageSize::Inch:
|
|
return QSizeF(qt_pageSizes[pageSizeId].widthInches, qt_pageSizes[pageSizeId].heightInches);
|
|
case QPageSize::Pica:
|
|
case QPageSize::Didot:
|
|
case QPageSize::Cicero:
|
|
return qt_convertPointsToUnits(QSize(qt_pageSizes[pageSizeId].widthPoints,
|
|
qt_pageSizes[pageSizeId].heightPoints), units);
|
|
}
|
|
return QSizeF();
|
|
}
|
|
|
|
// Find matching standard page size for point size
|
|
static QPageSize::PageSizeId qt_idForPointSize(const QSize &size, QPageSize::SizeMatchPolicy matchPolicy, QSize *match)
|
|
{
|
|
if (!size.isValid())
|
|
return QPageSize::Custom;
|
|
|
|
// Try exact match in portrait layout
|
|
for (int i = 0; i <= int(QPageSize::LastPageSize); ++i) {
|
|
if (size.width() == qt_pageSizes[i].widthPoints && size.height() == qt_pageSizes[i].heightPoints) {
|
|
if (match)
|
|
*match = QSize(qt_pageSizes[i].widthPoints, qt_pageSizes[i].heightPoints);
|
|
return qt_pageSizes[i].id;
|
|
}
|
|
}
|
|
|
|
// If no exact match only try fuzzy if asked
|
|
if (matchPolicy != QPageSize::ExactMatch) {
|
|
// Set up the fuzzy tolerance
|
|
// TODO Use ISO standard tolerance based on page size?
|
|
const int tolerance = 3; // = approx 1mm
|
|
const int minWidth = size.width() - tolerance;
|
|
const int maxWidth = size.width() + tolerance;
|
|
const int minHeight = size.height() - tolerance;
|
|
const int maxHeight = size.height() + tolerance;
|
|
|
|
// First try fuzzy match in portrait layout
|
|
for (int i = 0; i <= QPageSize::LastPageSize; ++i) {
|
|
const int width = qt_pageSizes[i].widthPoints;
|
|
const int height = qt_pageSizes[i].heightPoints;
|
|
if (width >= minWidth && width <= maxWidth && height >= minHeight && height <= maxHeight) {
|
|
if (match)
|
|
*match = QSize(qt_pageSizes[i].widthPoints, qt_pageSizes[i].heightPoints);
|
|
return qt_pageSizes[i].id;
|
|
}
|
|
}
|
|
|
|
// If FuzzyOrientationMatch then try rotated sizes
|
|
if (matchPolicy == QPageSize::FuzzyOrientationMatch) {
|
|
// First try exact match in landscape layout
|
|
for (int i = 0; i <= QPageSize::LastPageSize; ++i) {
|
|
if (size.width() == qt_pageSizes[i].heightPoints && size.height() == qt_pageSizes[i].widthPoints) {
|
|
if (match)
|
|
*match = QSize(qt_pageSizes[i].widthPoints, qt_pageSizes[i].heightPoints);
|
|
return qt_pageSizes[i].id;
|
|
}
|
|
}
|
|
|
|
// Then try fuzzy match in landscape layout
|
|
for (int i = 0; i <= QPageSize::LastPageSize; ++i) {
|
|
const int width = qt_pageSizes[i].heightPoints;
|
|
const int height = qt_pageSizes[i].widthPoints;
|
|
if (width >= minWidth && width <= maxWidth && height >= minHeight && height <= maxHeight) {
|
|
if (match)
|
|
*match = QSize(qt_pageSizes[i].widthPoints, qt_pageSizes[i].heightPoints);
|
|
return qt_pageSizes[i].id;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (match)
|
|
*match = size;
|
|
// Otherwise no match so Custom
|
|
return QPageSize::Custom;
|
|
}
|
|
|
|
// Find matching standard page size for point size
|
|
static QPageSize::PageSizeId qt_idForSize(const QSizeF &size, QPageSize::Unit units,
|
|
QPageSize::SizeMatchPolicy matchPolicy, QSize *match)
|
|
{
|
|
if (!size.isValid())
|
|
return QPageSize::Custom;
|
|
|
|
// Try exact match if units are the same
|
|
if (units == QPageSize::Millimeter) {
|
|
for (int i = 0; i <= QPageSize::LastPageSize; ++i) {
|
|
if (size.width() == qt_pageSizes[i].widthMillimeters && size.height() == qt_pageSizes[i].heightMillimeters) {
|
|
if (match)
|
|
*match = QSize(qt_pageSizes[i].widthPoints, qt_pageSizes[i].heightPoints);
|
|
return qt_pageSizes[i].id;
|
|
}
|
|
}
|
|
} else if (units == QPageSize::Inch) {
|
|
for (int i = 0; i <= QPageSize::LastPageSize; ++i) {
|
|
if (size.width() == qt_pageSizes[i].widthInches && size.height() == qt_pageSizes[i].heightInches) {
|
|
if (match)
|
|
*match = QSize(qt_pageSizes[i].widthPoints, qt_pageSizes[i].heightPoints);
|
|
return qt_pageSizes[i].id;
|
|
}
|
|
}
|
|
} else if (units == QPageSize::Point) {
|
|
for (int i = 0; i <= QPageSize::LastPageSize; ++i) {
|
|
if (size.width() == qt_pageSizes[i].widthPoints && size.height() == qt_pageSizes[i].heightPoints) {
|
|
if (match)
|
|
*match = QSize(qt_pageSizes[i].widthPoints, qt_pageSizes[i].heightPoints);
|
|
return qt_pageSizes[i].id;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If no exact match then convert to points and try match those
|
|
QSize points = qt_convertUnitsToPoints(size, units);
|
|
return qt_idForPointSize(points, matchPolicy, match);
|
|
}
|
|
|
|
class QPageSizePrivate : public QSharedData
|
|
{
|
|
public:
|
|
QPageSizePrivate();
|
|
explicit QPageSizePrivate(QPageSize::PageSizeId pageSizeId);
|
|
QPageSizePrivate(const QSize &pointSize,
|
|
const QString &name,
|
|
QPageSize::SizeMatchPolicy matchPolicy);
|
|
QPageSizePrivate(const QSizeF &size, QPageSize::Unit units,
|
|
const QString &name,
|
|
QPageSize::SizeMatchPolicy matchPolicy);
|
|
QPageSizePrivate(const QString &key, const QSize &size, const QString &name);
|
|
QPageSizePrivate(int windowsId, const QSize &pointSize, const QString &name);
|
|
~QPageSizePrivate();
|
|
|
|
bool operator==(const QPageSizePrivate &other) const;
|
|
bool isEquivalentTo(const QPageSizePrivate &other) const;
|
|
|
|
bool isValid() const;
|
|
|
|
QSizeF size(QPageSize::Unit units) const;
|
|
QSize sizePixels(int resolution) const;
|
|
|
|
private:
|
|
friend class QPageSize;
|
|
|
|
void init(QPageSize::PageSizeId id, const QString &name);
|
|
void init(const QSize &size, const QString &name);
|
|
void init(const QSizeF &size, QPageSize::Unit units, const QString &name);
|
|
|
|
QString m_key;
|
|
QPageSize::PageSizeId m_id;
|
|
QSize m_pointSize;
|
|
QString m_name;
|
|
int m_windowsId;
|
|
QSizeF m_size;
|
|
QPageSize::Unit m_units;
|
|
};
|
|
|
|
QPageSizePrivate::QPageSizePrivate()
|
|
: m_id(QPageSize::Custom),
|
|
m_windowsId(0),
|
|
m_units(QPageSize::Point)
|
|
{
|
|
}
|
|
|
|
QPageSizePrivate::QPageSizePrivate(QPageSize::PageSizeId pageSizeId)
|
|
: m_id(QPageSize::Custom),
|
|
m_windowsId(0),
|
|
m_units(QPageSize::Point)
|
|
{
|
|
if (unsigned(pageSizeId) <= unsigned(QPageSize::LastPageSize))
|
|
init(pageSizeId, QString());
|
|
}
|
|
|
|
QPageSizePrivate::QPageSizePrivate(const QSize &pointSize, const QString &name, QPageSize::SizeMatchPolicy matchPolicy)
|
|
: m_id(QPageSize::Custom),
|
|
m_windowsId(0),
|
|
m_units(QPageSize::Point)
|
|
{
|
|
if (pointSize.isValid()) {
|
|
QPageSize::PageSizeId id = qt_idForPointSize(pointSize, matchPolicy, 0);
|
|
id == QPageSize::Custom ? init(pointSize, name) : init(id, name);
|
|
}
|
|
}
|
|
|
|
QPageSizePrivate::QPageSizePrivate(const QSizeF &size, QPageSize::Unit units,
|
|
const QString &name, QPageSize::SizeMatchPolicy matchPolicy)
|
|
: m_id(QPageSize::Custom),
|
|
m_windowsId(0),
|
|
m_units(QPageSize::Point)
|
|
{
|
|
if (size.isValid()) {
|
|
QPageSize::PageSizeId id = qt_idForSize(size, units, matchPolicy, 0);
|
|
id == QPageSize::Custom ? init(size, units, name) : init(id, name);
|
|
}
|
|
}
|
|
|
|
QPageSizePrivate::QPageSizePrivate(const QString &key, const QSize &pointSize, const QString &name)
|
|
: m_id(QPageSize::Custom),
|
|
m_windowsId(0),
|
|
m_units(QPageSize::Point)
|
|
{
|
|
if (!key.isEmpty() && pointSize.isValid()) {
|
|
QPageSize::PageSizeId id = qt_idForPpdKey(key, 0);
|
|
// If not a known PPD key, check if size is a standard PPD size
|
|
if (id == QPageSize::Custom)
|
|
id = qt_idForPointSize(pointSize, QPageSize::FuzzyMatch, 0);
|
|
id == QPageSize::Custom ? init(pointSize, name) : init(id, name);
|
|
m_key = key;
|
|
}
|
|
}
|
|
|
|
QPageSizePrivate::QPageSizePrivate(int windowsId, const QSize &pointSize, const QString &name)
|
|
: m_id(QPageSize::Custom),
|
|
m_windowsId(0),
|
|
m_units(QPageSize::Point)
|
|
{
|
|
if (windowsId > 0 && pointSize.isValid()) {
|
|
QPageSize::PageSizeId id = qt_idForWindowsID(windowsId, 0);
|
|
// If not a known Windows ID, check if size is a standard PPD size
|
|
if (id == QPageSize::Custom)
|
|
id = qt_idForPointSize(pointSize, QPageSize::FuzzyMatch, 0);
|
|
id == QPageSize::Custom ? init(pointSize, name) : init(id, name);
|
|
m_windowsId = windowsId;
|
|
}
|
|
}
|
|
|
|
QPageSizePrivate::~QPageSizePrivate()
|
|
{
|
|
}
|
|
|
|
// Init a standard PageSizeId
|
|
void QPageSizePrivate::init(QPageSize::PageSizeId id, const QString &name)
|
|
{
|
|
m_id = id;
|
|
m_size = qt_definitionSize(id);
|
|
m_units = qt_pageSizes[id].definitionUnits;
|
|
m_key = qt_keyForPageSizeId(id);
|
|
m_name = name.isEmpty() ? QPageSize::name(id) : name;
|
|
m_windowsId = qt_pageSizes[id].windowsId;
|
|
m_pointSize = QSize(qt_pageSizes[id].widthPoints, qt_pageSizes[id].heightPoints);
|
|
}
|
|
|
|
// Init a point size
|
|
void QPageSizePrivate::init(const QSize &size, const QString &name)
|
|
{
|
|
m_id = QPageSize::Custom;
|
|
m_size = size;
|
|
m_units = QPageSize::Point;
|
|
m_key = qt_keyForCustomSize(m_size, m_units);
|
|
m_name = name.isEmpty() ? qt_nameForCustomSize(m_size, m_units) : name;
|
|
m_windowsId = 0;
|
|
m_pointSize = size;
|
|
}
|
|
|
|
// Init a unit size
|
|
void QPageSizePrivate::init(const QSizeF &size, QPageSize::Unit units, const QString &name)
|
|
{
|
|
m_id = QPageSize::Custom;
|
|
m_size = size;
|
|
m_units = units;
|
|
m_key = qt_keyForCustomSize(m_size, m_units);
|
|
if (name.isEmpty())
|
|
m_name = qt_nameForCustomSize(m_size, m_units);
|
|
else
|
|
m_name = name;
|
|
m_windowsId = 0;
|
|
m_pointSize = qt_convertUnitsToPoints(m_size, m_units);
|
|
}
|
|
|
|
bool QPageSizePrivate::operator==(const QPageSizePrivate &other) const
|
|
{
|
|
return m_size == other.m_size
|
|
&& m_units == other.m_units
|
|
&& m_key == other.m_key
|
|
&& m_name == other.m_name;
|
|
}
|
|
|
|
bool QPageSizePrivate::isEquivalentTo(const QPageSizePrivate &other) const
|
|
{
|
|
return m_pointSize == other.m_pointSize;
|
|
}
|
|
|
|
bool QPageSizePrivate::isValid() const
|
|
{
|
|
return m_pointSize.isValid() && !m_key.isEmpty() && !m_name.isEmpty();
|
|
}
|
|
|
|
QSizeF QPageSizePrivate::size(QPageSize::Unit units) const
|
|
{
|
|
// If want units we've stored in, we already have them
|
|
if (units == m_units)
|
|
return m_size;
|
|
|
|
// If want points we already have them
|
|
if (units == QPageSize::Point)
|
|
return QSizeF(m_pointSize.width(), m_pointSize.height());
|
|
|
|
// If a custom size do a conversion
|
|
if (m_id == QPageSize::Custom)
|
|
return qt_convertUnits(m_size, m_units, units);
|
|
|
|
// Otherwise use the standard sizes
|
|
return qt_unitSize(m_id, units);
|
|
}
|
|
|
|
QSize QPageSizePrivate::sizePixels(int resolution) const
|
|
{
|
|
return qt_convertPointsToPixels(m_pointSize, resolution);;
|
|
}
|
|
|
|
|
|
/*!
|
|
\class QPageSize
|
|
\inmodule QtGui
|
|
\since 5.3
|
|
\brief The QPageSize class describes the size and name of a defined page size
|
|
|
|
This class implements support for the set of standard page sizes as defined
|
|
in the Adobe Postscript PPD Standard v4.3. It defines the standard set of
|
|
page sizes in points, millimeters and inches and ensures these sizes are
|
|
consistently used. Other size units can be used but will be calculated
|
|
results and so may not always be consistent. The defined point sizes are
|
|
always a integer, all other sizes can be fractions of a unit.
|
|
|
|
The defined size is always in width x height order with no implied page
|
|
orientation. Note that it is possible for page sizes to be defined where the
|
|
width is greater than the height, such as QPageSize::Ledger, so you cannot
|
|
rely on comparing the width and height values to determine page orientation.
|
|
|
|
For example, A4 is defined by the standard as 210mm x 297mm, 8.27in x 11.69in,
|
|
or 595pt x 842pt.
|
|
|
|
You can also define custom page sizes with custom names in any units you want
|
|
and this unit size will be preserved and used as the base for all other unit
|
|
size calculations.
|
|
|
|
When creating a QPageSize using a custom QSize you can choose if you want
|
|
QPageSize to try match the size to a standard page size. By default
|
|
QPaperSize uses a FuzzyMatch mode where it will match a given page size to
|
|
a standard page size if it falls within 3 postscript points of a defined
|
|
standard size. You can override this to request only an exact match but this
|
|
is not recommended as conversions between units can easily lose 3 points and
|
|
result in incorrect page sizes.
|
|
|
|
A QPageSize instance may also be obtained by querying the supported page sizes
|
|
for a print device. In this case the localized name returned is that defined
|
|
by the printer itself. Note that the print device may not support the current
|
|
default locale language.
|
|
|
|
The class also provides convenience methods for converting page size IDs to and from
|
|
various unit sizes.
|
|
|
|
\sa QPagedPaintDevice, QPdfWriter
|
|
*/
|
|
|
|
/*!
|
|
\enum QPageSize::PageSizeId
|
|
|
|
This enum type lists the available page sizes as defined in the Postscript
|
|
PPD standard. These values are duplicated in QPagedPaintDevice and QPrinter.
|
|
|
|
The defined sizes are:
|
|
|
|
\value A0 841 x 1189 mm
|
|
\value A1 594 x 841 mm
|
|
\value A2 420 x 594 mm
|
|
\value A3 297 x 420 mm
|
|
\value A4 210 x 297 mm, 8.26 x 11.69 inches
|
|
\value A5 148 x 210 mm
|
|
\value A6 105 x 148 mm
|
|
\value A7 74 x 105 mm
|
|
\value A8 52 x 74 mm
|
|
\value A9 37 x 52 mm
|
|
\value B0 1000 x 1414 mm
|
|
\value B1 707 x 1000 mm
|
|
\value B2 500 x 707 mm
|
|
\value B3 353 x 500 mm
|
|
\value B4 250 x 353 mm
|
|
\value B5 176 x 250 mm, 6.93 x 9.84 inches
|
|
\value B6 125 x 176 mm
|
|
\value B7 88 x 125 mm
|
|
\value B8 62 x 88 mm
|
|
\value B9 44 x 62 mm
|
|
\value B10 31 x 44 mm
|
|
\value C5E 163 x 229 mm
|
|
\value Comm10E 105 x 241 mm, U.S. Common 10 Envelope
|
|
\value DLE 110 x 220 mm
|
|
\value Executive 7.5 x 10 inches, 190.5 x 254 mm
|
|
\value Folio 210 x 330 mm
|
|
\value Ledger 431.8 x 279.4 mm
|
|
\value Legal 8.5 x 14 inches, 215.9 x 355.6 mm
|
|
\value Letter 8.5 x 11 inches, 215.9 x 279.4 mm
|
|
\value Tabloid 279.4 x 431.8 mm
|
|
\value Custom Unknown, or a user defined size.
|
|
\value A10
|
|
\value A3Extra
|
|
\value A4Extra
|
|
\value A4Plus
|
|
\value A4Small
|
|
\value A5Extra
|
|
\value B5Extra
|
|
\value JisB0
|
|
\value JisB1
|
|
\value JisB2
|
|
\value JisB3
|
|
\value JisB4
|
|
\value JisB5
|
|
\value JisB6,
|
|
\value JisB7
|
|
\value JisB8
|
|
\value JisB9
|
|
\value JisB10
|
|
\value AnsiA = Letter
|
|
\value AnsiB = Ledger
|
|
\value AnsiC
|
|
\value AnsiD
|
|
\value AnsiE
|
|
\value LegalExtra
|
|
\value LetterExtra
|
|
\value LetterPlus
|
|
\value LetterSmall
|
|
\value TabloidExtra
|
|
\value ArchA
|
|
\value ArchB
|
|
\value ArchC
|
|
\value ArchD
|
|
\value ArchE
|
|
\value Imperial7x9
|
|
\value Imperial8x10
|
|
\value Imperial9x11
|
|
\value Imperial9x12
|
|
\value Imperial10x11
|
|
\value Imperial10x13
|
|
\value Imperial10x14
|
|
\value Imperial12x11
|
|
\value Imperial15x11
|
|
\value ExecutiveStandard
|
|
\value Note
|
|
\value Quarto
|
|
\value Statement
|
|
\value SuperA
|
|
\value SuperB
|
|
\value Postcard
|
|
\value DoublePostcard
|
|
\value Prc16K
|
|
\value Prc32K
|
|
\value Prc32KBig
|
|
\value FanFoldUS
|
|
\value FanFoldGerman
|
|
\value FanFoldGermanLegal
|
|
\value EnvelopeB4
|
|
\value EnvelopeB5
|
|
\value EnvelopeB6
|
|
\value EnvelopeC0
|
|
\value EnvelopeC1
|
|
\value EnvelopeC2
|
|
\value EnvelopeC3
|
|
\value EnvelopeC4
|
|
\value EnvelopeC5 = C5E
|
|
\value EnvelopeC6
|
|
\value EnvelopeC65
|
|
\value EnvelopeC7
|
|
\value EnvelopeDL = DLE
|
|
\value Envelope9
|
|
\value Envelope10 = Comm10E
|
|
\value Envelope11
|
|
\value Envelope12
|
|
\value Envelope14
|
|
\value EnvelopeMonarch
|
|
\value EnvelopePersonal
|
|
\value EnvelopeChou3
|
|
\value EnvelopeChou4
|
|
\value EnvelopeInvite
|
|
\value EnvelopeItalian
|
|
\value EnvelopeKaku2
|
|
\value EnvelopeKaku3
|
|
\value EnvelopePrc1
|
|
\value EnvelopePrc2
|
|
\value EnvelopePrc3
|
|
\value EnvelopePrc4
|
|
\value EnvelopePrc5
|
|
\value EnvelopePrc6
|
|
\value EnvelopePrc7
|
|
\value EnvelopePrc8
|
|
\value EnvelopePrc9
|
|
\value EnvelopePrc10
|
|
\value EnvelopeYou4
|
|
\value LastPageSize = EnvelopeYou4
|
|
\omitvalue NPageSize
|
|
\omitvalue NPaperSize
|
|
|
|
Due to historic reasons QPageSize::Executive is not the same as the standard
|
|
Postscript and Windows Executive size, use QPageSize::ExecutiveStandard instead.
|
|
|
|
The Postscript standard size QPageSize::Folio is different to the Windows
|
|
DMPAPER_FOLIO size, use the Postscript standard size QPageSize::FanFoldGermanLegal
|
|
if needed.
|
|
*/
|
|
|
|
/*!
|
|
\enum QPageSize::Unit
|
|
|
|
This enum type is used to specify the measurement unit for page sizes.
|
|
|
|
\value Millimeter
|
|
\value Point 1/72th of an inch
|
|
\value Inch
|
|
\value Pica 1/72th of a foot, 1/6th of an inch, 12 Points
|
|
\value Didot 1/72th of a French inch, 0.375 mm
|
|
\value Cicero 1/6th of a French inch, 12 Didot, 4.5mm
|
|
*/
|
|
|
|
/*!
|
|
\enum QPageSize::SizeMatchPolicy
|
|
|
|
\value FuzzyMatch Match to a standard page size if within the margin of tolerance.
|
|
\value FuzzyOrientationMatch Match to a standard page size if within the margin of tolerance regardless of orientation.
|
|
\value ExactMatch Only match to a standard page size if the sizes match exactly.
|
|
*/
|
|
|
|
/*!
|
|
Creates a null QPageSize.
|
|
*/
|
|
|
|
QPageSize::QPageSize()
|
|
: d(new QPageSizePrivate())
|
|
{
|
|
}
|
|
|
|
/*!
|
|
Creates a QPageSize of the standard \a pageSize.
|
|
|
|
If \a pageSize is QPageSize::Custom then the resulting QPageSize will not
|
|
be valid. Use the custom size constructor instead.
|
|
*/
|
|
|
|
QPageSize::QPageSize(PageSizeId pageSize)
|
|
: d(new QPageSizePrivate(pageSize))
|
|
{
|
|
}
|
|
|
|
/*!
|
|
Creates a QPageSize of the given \a pointSize in Points using the matching \a matchPolicy.
|
|
|
|
If the given \a pointSize matches a standard QPageSize::PageSizeId, then that page
|
|
size will be used. Note that if the \a matchPolicy is FuzzyMatch this may result
|
|
in the \a pointSize being adjusted to the standard size. To prevent this happening
|
|
use a \a matchPolicy of ExactMatch instead.
|
|
|
|
If the given \a pointSize is not a standard QPageSize::PageSizeId then a QPageSize::Custom
|
|
size will be created.
|
|
|
|
If \a name is null then the standard localized name will be used. If a custom page
|
|
size then a custom name in the format "Custom (width x height)" will be created.
|
|
|
|
The \a matchPolicy defaults to FuzzyMatch.
|
|
*/
|
|
|
|
QPageSize::QPageSize(const QSize &pointSize, const QString &name, SizeMatchPolicy matchPolicy)
|
|
: d(new QPageSizePrivate(pointSize, name, matchPolicy))
|
|
{
|
|
}
|
|
|
|
/*!
|
|
Creates a custom page of the given \a size in \a units.
|
|
|
|
If the given \a size matches a standard QPageSize::PageSizeId, then that page
|
|
size will be used. Note that if the \a matchPolicy is FuzzyMatch this may result
|
|
in the \a size being adjusted to the standard size. To prevent this happening
|
|
use a \a matchPolicy of ExactMatch instead.
|
|
|
|
If the given \a size is not a standard QPageSize::PageSizeId then a QPageSize::Custom
|
|
size will be created. The original unit size will be preserved and used as the
|
|
base for all other unit size calculations.
|
|
|
|
If \a name is null then a custom name will be created in the form
|
|
"Custom (width x height)" where the size is expressed in units provided.
|
|
*/
|
|
|
|
QPageSize::QPageSize(const QSizeF &size, Unit units,
|
|
const QString &name, SizeMatchPolicy matchPolicy)
|
|
: d(new QPageSizePrivate(size, units, name, matchPolicy))
|
|
{
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
|
|
Create page with given key, size and name, for use by printer plugin.
|
|
*/
|
|
|
|
QPageSize::QPageSize(const QString &key, const QSize &pointSize, const QString &name)
|
|
: d(new QPageSizePrivate(key, pointSize, name))
|
|
{
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
|
|
Create page with given windows ID, size and name, for use by printer plugin.
|
|
*/
|
|
|
|
QPageSize::QPageSize(int windowsId, const QSize &pointSize, const QString &name)
|
|
: d(new QPageSizePrivate(windowsId, pointSize, name))
|
|
{
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
|
|
Create page with given private backend
|
|
*/
|
|
|
|
QPageSize::QPageSize(QPageSizePrivate &dd)
|
|
: d(&dd)
|
|
{
|
|
}
|
|
|
|
/*!
|
|
Copy constructor, copies \a other to this.
|
|
*/
|
|
|
|
QPageSize::QPageSize(const QPageSize &other)
|
|
: d(other.d)
|
|
{
|
|
}
|
|
|
|
/*!
|
|
Destroys the page.
|
|
*/
|
|
|
|
QPageSize::~QPageSize()
|
|
{
|
|
}
|
|
|
|
/*!
|
|
Assignment operator, assigns \a other to this.
|
|
*/
|
|
|
|
QPageSize &QPageSize::operator=(const QPageSize &other)
|
|
{
|
|
d = other.d;
|
|
return *this;
|
|
}
|
|
|
|
/*!
|
|
\fn void QPageSize::swap(QPageSize &other)
|
|
|
|
Swaps this QPageSize with \a other. This function is very fast and
|
|
never fails.
|
|
*/
|
|
|
|
/*!
|
|
\fn QPageSize &QPageSize::operator=(QPageSize &&other)
|
|
|
|
Move-assigns \a other to this QPageSize instance, transferring the
|
|
ownership of the managed pointer to this instance.
|
|
*/
|
|
|
|
/*!
|
|
\relates QPageSize
|
|
|
|
Returns \c true if page size \a lhs is equal to page size \a rhs,
|
|
i.e. if the page sizes have the same attributes. Current
|
|
attributes are size and name.
|
|
*/
|
|
|
|
bool operator==(const QPageSize &lhs, const QPageSize &rhs)
|
|
{
|
|
return lhs.d == rhs.d || *lhs.d == *rhs.d;
|
|
}
|
|
/*!
|
|
\fn bool operator!=(const QPageSize &lhs, const QPageSize &rhs)
|
|
\relates QPageSize
|
|
|
|
Returns \c true if page size \a lhs is unequal to page size \a
|
|
rhs, i.e. if the page size has different attributes. Current
|
|
attributes are size and name.
|
|
*/
|
|
|
|
/*!
|
|
Returns \c true if this page is equivalent to the \a other page, i.e. if the
|
|
page has the same size regardless of other attributes like name.
|
|
*/
|
|
|
|
bool QPageSize::isEquivalentTo(const QPageSize &other) const
|
|
{
|
|
if (d == other.d)
|
|
return true;
|
|
return d && other.d && d->isEquivalentTo(*other.d);
|
|
}
|
|
|
|
/*!
|
|
Returns \c true if this page size is valid.
|
|
|
|
The page size may be invalid if created with an invalid PageSizeId, or a
|
|
negative or invalid QSize or QSizeF, or the null constructor.
|
|
*/
|
|
|
|
bool QPageSize::isValid() const
|
|
{
|
|
return d && d->isValid();
|
|
}
|
|
|
|
/*!
|
|
Returns the unique key of the page size.
|
|
|
|
By default this is the PPD standard mediaOption keyword for the page size,
|
|
or the PPD custom format key. If the QPageSize instance was obtained from
|
|
a print device then this will be the key provided by the print device and
|
|
may differ from the standard key.
|
|
|
|
If the QPageSize is invalid then the key will be an empty string.
|
|
|
|
This key should never be shown to end users, it is an internal key only.
|
|
For a human-readable name use name().
|
|
|
|
\sa name()
|
|
*/
|
|
|
|
QString QPageSize::key() const
|
|
{
|
|
return isValid() ? d->m_key : QString();
|
|
}
|
|
|
|
/*!
|
|
Returns a localized human-readable name for the page size.
|
|
|
|
If the QPageSize instance was obtained from a print device then the name
|
|
used is that provided by the print device. Note that a print device may
|
|
not support the current default locale language.
|
|
|
|
If the QPageSize is invalid then the name will be an empty string.
|
|
*/
|
|
|
|
QString QPageSize::name() const
|
|
{
|
|
return isValid() ? d->m_name : QString();
|
|
}
|
|
|
|
/*!
|
|
Returns the standard QPageSize::PageSizeId of the page, or QPageSize::Custom.
|
|
|
|
If the QPageSize is invalid then the ID will be QPageSize::Custom.
|
|
*/
|
|
|
|
QPageSize::PageSizeId QPageSize::id() const
|
|
{
|
|
return isValid() ? d->m_id : Custom;
|
|
}
|
|
|
|
/*!
|
|
Returns the Windows DMPAPER enum value for the page size.
|
|
|
|
Not all valid PPD page sizes have a Windows equivalent, in which case 0
|
|
will be returned.
|
|
|
|
If the QPageSize is invalid then the Windows ID will be 0.
|
|
|
|
\sa id()
|
|
*/
|
|
|
|
int QPageSize::windowsId() const
|
|
{
|
|
if (!isValid())
|
|
return 0;
|
|
return d->m_windowsId > 0 ? d->m_windowsId : windowsId(d->m_id);
|
|
}
|
|
|
|
/*!
|
|
Returns the definition size of the page size.
|
|
|
|
For a standard page size this will be the size as defined in the relevant
|
|
standard, i.e. ISO A4 will be defined in millimeters while ANSI Letter will
|
|
be defined in inches.
|
|
|
|
For a custom page size this will be the original size used to create the
|
|
page size object.
|
|
|
|
If the QPageSize is invalid then the QSizeF will be invalid.
|
|
|
|
\sa definitionUnits()
|
|
*/
|
|
|
|
QSizeF QPageSize::definitionSize() const
|
|
{
|
|
return isValid() ? d->m_size : QSizeF();
|
|
}
|
|
|
|
/*!
|
|
Returns the definition units of the page size.
|
|
|
|
For a standard page size this will be the units as defined in the relevant
|
|
standard, i.e. ISO A4 will be defined in millimeters while ANSI Letter will
|
|
be defined in inches.
|
|
|
|
For a custom page size this will be the original units used to create the
|
|
page size object.
|
|
|
|
If the QPageSize is invalid then the QPageSize::Unit will be invalid.
|
|
|
|
\sa definitionSize()
|
|
*/
|
|
|
|
QPageSize::Unit QPageSize::definitionUnits() const
|
|
{
|
|
return isValid() ? d->m_units : Unit(-1);
|
|
}
|
|
|
|
/*!
|
|
Returns the size of the page in the required \a units.
|
|
|
|
If the QPageSize is invalid then the QSizeF will be invalid.
|
|
*/
|
|
|
|
QSizeF QPageSize::size(Unit units) const
|
|
{
|
|
return isValid() ? d->size(units) : QSize();
|
|
}
|
|
|
|
/*!
|
|
Returns the size of the page in Postscript Points (1/72 of an inch).
|
|
|
|
If the QPageSize is invalid then the QSize will be invalid.
|
|
*/
|
|
|
|
QSize QPageSize::sizePoints() const
|
|
{
|
|
return isValid() ? d->m_pointSize : QSize();
|
|
}
|
|
|
|
/*!
|
|
Returns the size of the page in Device Pixels at the given \a resolution.
|
|
|
|
If the QPageSize is invalid then the QSize will be invalid.
|
|
*/
|
|
|
|
QSize QPageSize::sizePixels(int resolution) const
|
|
{
|
|
return isValid() ? d->sizePixels(resolution) : QSize();
|
|
}
|
|
|
|
/*!
|
|
Returns the page rectangle in the required \a units.
|
|
|
|
If the QPageSize is invalid then the QRect will be invalid.
|
|
*/
|
|
|
|
QRectF QPageSize::rect(Unit units) const
|
|
{
|
|
return isValid() ? QRectF(QPointF(0, 0), d->size(units)) : QRectF();
|
|
}
|
|
|
|
/*!
|
|
Returns the page rectangle in Postscript Points (1/72 of an inch).
|
|
|
|
If the QPageSize is invalid then the QRect will be invalid.
|
|
*/
|
|
|
|
QRect QPageSize::rectPoints() const
|
|
{
|
|
return isValid() ? QRect(QPoint(0, 0), d->m_pointSize) : QRect();
|
|
}
|
|
|
|
/*!
|
|
Returns the page rectangle in Device Pixels at the given \a resolution.
|
|
|
|
If the QPageSize is invalid then the QRect will be invalid.
|
|
*/
|
|
|
|
QRect QPageSize::rectPixels(int resolution) const
|
|
{
|
|
return isValid() ? QRect(QPoint(0, 0), d->sizePixels(resolution)) : QRect();
|
|
}
|
|
|
|
// Statics
|
|
|
|
/*!
|
|
Returns the PPD mediaOption keyword of the standard \a pageSizeId.
|
|
|
|
If the QPageSize is invalid then the key will be empty.
|
|
*/
|
|
|
|
QString QPageSize::key(PageSizeId pageSizeId)
|
|
{
|
|
if (unsigned(pageSizeId) > unsigned(LastPageSize))
|
|
return QString();
|
|
return QString::fromUtf8(qt_pageSizes[pageSizeId].mediaOption);
|
|
}
|
|
|
|
static QString msgImperialPageSizeInch(int width, int height)
|
|
{
|
|
//: Page size in 'Inch'.
|
|
return QCoreApplication::translate("QPageSize", "%1 x %2 in").arg(width).arg(height);
|
|
}
|
|
|
|
/*!
|
|
Returns the localized name of the standard \a pageSizeId.
|
|
|
|
If the QPageSize is invalid then the name will be empty.
|
|
*/
|
|
|
|
QString QPageSize::name(PageSizeId pageSizeId)
|
|
{
|
|
if (unsigned(pageSizeId) > unsigned(LastPageSize))
|
|
return QString();
|
|
|
|
switch (pageSizeId) {
|
|
case A0:
|
|
return QCoreApplication::translate("QPageSize", "A0");
|
|
case A1:
|
|
return QCoreApplication::translate("QPageSize", "A1");
|
|
case A2:
|
|
return QCoreApplication::translate("QPageSize", "A2");
|
|
case A3:
|
|
return QCoreApplication::translate("QPageSize", "A3");
|
|
case A4:
|
|
return QCoreApplication::translate("QPageSize", "A4");
|
|
case A5:
|
|
return QCoreApplication::translate("QPageSize", "A5");
|
|
case A6:
|
|
return QCoreApplication::translate("QPageSize", "A6");
|
|
case A7:
|
|
return QCoreApplication::translate("QPageSize", "A7");
|
|
case A8:
|
|
return QCoreApplication::translate("QPageSize", "A8");
|
|
case A9:
|
|
return QCoreApplication::translate("QPageSize", "A9");
|
|
case A10:
|
|
return QCoreApplication::translate("QPageSize", "A10");
|
|
case B0:
|
|
return QCoreApplication::translate("QPageSize", "B0");
|
|
case B1:
|
|
return QCoreApplication::translate("QPageSize", "B1");
|
|
case B2:
|
|
return QCoreApplication::translate("QPageSize", "B2");
|
|
case B3:
|
|
return QCoreApplication::translate("QPageSize", "B3");
|
|
case B4:
|
|
return QCoreApplication::translate("QPageSize", "B4");
|
|
case B5:
|
|
return QCoreApplication::translate("QPageSize", "B5");
|
|
case B6:
|
|
return QCoreApplication::translate("QPageSize", "B6");
|
|
case B7:
|
|
return QCoreApplication::translate("QPageSize", "B7");
|
|
case B8:
|
|
return QCoreApplication::translate("QPageSize", "B8");
|
|
case B9:
|
|
return QCoreApplication::translate("QPageSize", "B9");
|
|
case B10:
|
|
return QCoreApplication::translate("QPageSize", "B10");
|
|
case Executive:
|
|
return QCoreApplication::translate("QPageSize", "Executive (7.5 x 10 in)");
|
|
case ExecutiveStandard:
|
|
return QCoreApplication::translate("QPageSize", "Executive (7.25 x 10.5 in)");
|
|
case Folio:
|
|
return QCoreApplication::translate("QPageSize", "Folio (8.27 x 13 in)");
|
|
case Legal:
|
|
return QCoreApplication::translate("QPageSize", "Legal");
|
|
case Letter:
|
|
return QCoreApplication::translate("QPageSize", "Letter / ANSI A");
|
|
case Tabloid:
|
|
return QCoreApplication::translate("QPageSize", "Tabloid / ANSI B");
|
|
case Ledger:
|
|
return QCoreApplication::translate("QPageSize", "Ledger / ANSI B");
|
|
case Custom:
|
|
return QCoreApplication::translate("QPageSize", "Custom");
|
|
case A3Extra:
|
|
return QCoreApplication::translate("QPageSize", "A3 Extra");
|
|
case A4Extra:
|
|
return QCoreApplication::translate("QPageSize", "A4 Extra");
|
|
case A4Plus:
|
|
return QCoreApplication::translate("QPageSize", "A4 Plus");
|
|
case A4Small:
|
|
return QCoreApplication::translate("QPageSize", "A4 Small");
|
|
case A5Extra:
|
|
return QCoreApplication::translate("QPageSize", "A5 Extra");
|
|
case B5Extra:
|
|
return QCoreApplication::translate("QPageSize", "B5 Extra");
|
|
case JisB0:
|
|
return QCoreApplication::translate("QPageSize", "JIS B0");
|
|
case JisB1:
|
|
return QCoreApplication::translate("QPageSize", "JIS B1");
|
|
case JisB2:
|
|
return QCoreApplication::translate("QPageSize", "JIS B2");
|
|
case JisB3:
|
|
return QCoreApplication::translate("QPageSize", "JIS B3");
|
|
case JisB4:
|
|
return QCoreApplication::translate("QPageSize", "JIS B4");
|
|
case JisB5:
|
|
return QCoreApplication::translate("QPageSize", "JIS B5");
|
|
case JisB6:
|
|
return QCoreApplication::translate("QPageSize", "JIS B6");
|
|
case JisB7:
|
|
return QCoreApplication::translate("QPageSize", "JIS B7");
|
|
case JisB8:
|
|
return QCoreApplication::translate("QPageSize", "JIS B8");
|
|
case JisB9:
|
|
return QCoreApplication::translate("QPageSize", "JIS B9");
|
|
case JisB10:
|
|
return QCoreApplication::translate("QPageSize", "JIS B10");
|
|
case AnsiC:
|
|
return QCoreApplication::translate("QPageSize", "ANSI C");
|
|
case AnsiD:
|
|
return QCoreApplication::translate("QPageSize", "ANSI D");
|
|
case AnsiE:
|
|
return QCoreApplication::translate("QPageSize", "ANSI E");
|
|
case LegalExtra:
|
|
return QCoreApplication::translate("QPageSize", "Legal Extra");
|
|
case LetterExtra:
|
|
return QCoreApplication::translate("QPageSize", "Letter Extra");
|
|
case LetterPlus:
|
|
return QCoreApplication::translate("QPageSize", "Letter Plus");
|
|
case LetterSmall:
|
|
return QCoreApplication::translate("QPageSize", "Letter Small");
|
|
case TabloidExtra:
|
|
return QCoreApplication::translate("QPageSize", "Tabloid Extra");
|
|
case ArchA:
|
|
return QCoreApplication::translate("QPageSize", "Architect A");
|
|
case ArchB:
|
|
return QCoreApplication::translate("QPageSize", "Architect B");
|
|
case ArchC:
|
|
return QCoreApplication::translate("QPageSize", "Architect C");
|
|
case ArchD:
|
|
return QCoreApplication::translate("QPageSize", "Architect D");
|
|
case ArchE:
|
|
return QCoreApplication::translate("QPageSize", "Architect E");
|
|
case Imperial7x9:
|
|
return msgImperialPageSizeInch(7, 9);
|
|
case Imperial8x10:
|
|
return msgImperialPageSizeInch(8, 10);
|
|
case Imperial9x11:
|
|
return msgImperialPageSizeInch(9, 11);
|
|
case Imperial9x12:
|
|
return msgImperialPageSizeInch(9, 12);
|
|
case Imperial10x11:
|
|
return msgImperialPageSizeInch(10, 11);
|
|
case Imperial10x13:
|
|
return msgImperialPageSizeInch(10, 13);
|
|
case Imperial10x14:
|
|
return msgImperialPageSizeInch(10, 14);
|
|
case Imperial12x11:
|
|
return msgImperialPageSizeInch(12, 11);
|
|
case Imperial15x11:
|
|
return msgImperialPageSizeInch(15, 11);
|
|
case Note:
|
|
return QCoreApplication::translate("QPageSize", "Note");
|
|
case Quarto:
|
|
return QCoreApplication::translate("QPageSize", "Quarto");
|
|
case Statement:
|
|
return QCoreApplication::translate("QPageSize", "Statement");
|
|
case SuperA:
|
|
return QCoreApplication::translate("QPageSize", "Super A");
|
|
case SuperB:
|
|
return QCoreApplication::translate("QPageSize", "Super B");
|
|
case Postcard:
|
|
return QCoreApplication::translate("QPageSize", "Postcard");
|
|
case DoublePostcard:
|
|
return QCoreApplication::translate("QPageSize", "Double Postcard");
|
|
case Prc16K:
|
|
return QCoreApplication::translate("QPageSize", "PRC 16K");
|
|
case Prc32K:
|
|
return QCoreApplication::translate("QPageSize", "PRC 32K");
|
|
case Prc32KBig:
|
|
return QCoreApplication::translate("QPageSize", "PRC 32K Big");
|
|
case FanFoldUS:
|
|
return QCoreApplication::translate("QPageSize", "Fan-fold US (14.875 x 11 in)");
|
|
case FanFoldGerman:
|
|
return QCoreApplication::translate("QPageSize", "Fan-fold German (8.5 x 12 in)");
|
|
case FanFoldGermanLegal:
|
|
return QCoreApplication::translate("QPageSize", "Fan-fold German Legal (8.5 x 13 in)");
|
|
case EnvelopeB4:
|
|
return QCoreApplication::translate("QPageSize", "Envelope B4");
|
|
case EnvelopeB5:
|
|
return QCoreApplication::translate("QPageSize", "Envelope B5");
|
|
case EnvelopeB6:
|
|
return QCoreApplication::translate("QPageSize", "Envelope B6");
|
|
case EnvelopeC0:
|
|
return QCoreApplication::translate("QPageSize", "Envelope C0");
|
|
case EnvelopeC1:
|
|
return QCoreApplication::translate("QPageSize", "Envelope C1");
|
|
case EnvelopeC2:
|
|
return QCoreApplication::translate("QPageSize", "Envelope C2");
|
|
case EnvelopeC3:
|
|
return QCoreApplication::translate("QPageSize", "Envelope C3");
|
|
case EnvelopeC4:
|
|
return QCoreApplication::translate("QPageSize", "Envelope C4");
|
|
case EnvelopeC5: // C5E
|
|
return QCoreApplication::translate("QPageSize", "Envelope C5");
|
|
case EnvelopeC6:
|
|
return QCoreApplication::translate("QPageSize", "Envelope C6");
|
|
case EnvelopeC65:
|
|
return QCoreApplication::translate("QPageSize", "Envelope C65");
|
|
case EnvelopeC7:
|
|
return QCoreApplication::translate("QPageSize", "Envelope C7");
|
|
case EnvelopeDL: // DLE:
|
|
return QCoreApplication::translate("QPageSize", "Envelope DL");
|
|
case Envelope9:
|
|
return QCoreApplication::translate("QPageSize", "Envelope US 9");
|
|
case Envelope10: // Comm10E
|
|
return QCoreApplication::translate("QPageSize", "Envelope US 10");
|
|
case Envelope11:
|
|
return QCoreApplication::translate("QPageSize", "Envelope US 11");
|
|
case Envelope12:
|
|
return QCoreApplication::translate("QPageSize", "Envelope US 12");
|
|
case Envelope14:
|
|
return QCoreApplication::translate("QPageSize", "Envelope US 14");
|
|
case EnvelopeMonarch:
|
|
return QCoreApplication::translate("QPageSize", "Envelope Monarch");
|
|
case EnvelopePersonal:
|
|
return QCoreApplication::translate("QPageSize", "Envelope Personal");
|
|
case EnvelopeChou3:
|
|
return QCoreApplication::translate("QPageSize", "Envelope Chou 3");
|
|
case EnvelopeChou4:
|
|
return QCoreApplication::translate("QPageSize", "Envelope Chou 4");
|
|
case EnvelopeInvite:
|
|
return QCoreApplication::translate("QPageSize", "Envelope Invite");
|
|
case EnvelopeItalian:
|
|
return QCoreApplication::translate("QPageSize", "Envelope Italian");
|
|
case EnvelopeKaku2:
|
|
return QCoreApplication::translate("QPageSize", "Envelope Kaku 2");
|
|
case EnvelopeKaku3:
|
|
return QCoreApplication::translate("QPageSize", "Envelope Kaku 3");
|
|
case EnvelopePrc1:
|
|
return QCoreApplication::translate("QPageSize", "Envelope PRC 1");
|
|
case EnvelopePrc2:
|
|
return QCoreApplication::translate("QPageSize", "Envelope PRC 2");
|
|
case EnvelopePrc3:
|
|
return QCoreApplication::translate("QPageSize", "Envelope PRC 3");
|
|
case EnvelopePrc4:
|
|
return QCoreApplication::translate("QPageSize", "Envelope PRC 4");
|
|
case EnvelopePrc5:
|
|
return QCoreApplication::translate("QPageSize", "Envelope PRC 5");
|
|
case EnvelopePrc6:
|
|
return QCoreApplication::translate("QPageSize", "Envelope PRC 6");
|
|
case EnvelopePrc7:
|
|
return QCoreApplication::translate("QPageSize", "Envelope PRC 7");
|
|
case EnvelopePrc8:
|
|
return QCoreApplication::translate("QPageSize", "Envelope PRC 8");
|
|
case EnvelopePrc9:
|
|
return QCoreApplication::translate("QPageSize", "Envelope PRC 9");
|
|
case EnvelopePrc10:
|
|
return QCoreApplication::translate("QPageSize", "Envelope PRC 10");
|
|
case EnvelopeYou4:
|
|
return QCoreApplication::translate("QPageSize", "Envelope You 4");
|
|
}
|
|
return QString();
|
|
}
|
|
|
|
/*!
|
|
Returns the standard QPageSize::PageSizeId of the given \a pointSize in
|
|
points using the given \a matchPolicy.
|
|
|
|
If using FuzzyMatch then the point size of the PageSizeId returned may not
|
|
exactly match the \a pointSize you passed in. You should call
|
|
QPageSize::sizePoints() using the returned PageSizeId to find out the actual
|
|
point size of the PageSizeId before using it in any calculations.
|
|
*/
|
|
|
|
QPageSize::PageSizeId QPageSize::id(const QSize &pointSize, SizeMatchPolicy matchPolicy)
|
|
{
|
|
return qt_idForPointSize(pointSize, matchPolicy, 0);
|
|
}
|
|
|
|
/*!
|
|
Returns the standard QPageSize::PageSizeId of the given \a size in \a units
|
|
using the given \a matchPolicy.
|
|
|
|
If using FuzzyMatch then the unit size of the PageSizeId returned may not
|
|
exactly match the \a size you passed in. You should call
|
|
QPageSize::size() using the returned PageSizeId to find out the actual
|
|
unit size of the PageSizeId before using it in any calculations.
|
|
*/
|
|
|
|
QPageSize::PageSizeId QPageSize::id(const QSizeF &size, Unit units,
|
|
SizeMatchPolicy matchPolicy)
|
|
{
|
|
return qt_idForSize(size, units, matchPolicy, 0);
|
|
}
|
|
|
|
/*!
|
|
Returns the PageSizeId for the given Windows DMPAPER enum value \a windowsId.
|
|
|
|
If there is no matching PageSizeId then QPageSize::Custom is returned.
|
|
*/
|
|
|
|
QPageSize::PageSizeId QPageSize::id(int windowsId)
|
|
{
|
|
return qt_idForWindowsID(windowsId);
|
|
}
|
|
|
|
/*!
|
|
Returns the Windows DMPAPER enum value of the standard \a pageSizeId.
|
|
|
|
Not all valid PPD page sizes have a Windows equivalent, in which case 0
|
|
will be returned.
|
|
*/
|
|
|
|
int QPageSize::windowsId(PageSizeId pageSizeId)
|
|
{
|
|
return qt_pageSizes[pageSizeId].windowsId;
|
|
}
|
|
|
|
/*!
|
|
Returns the definition size of the standard \a pageSizeId.
|
|
|
|
To obtain the definition units, call QPageSize::definitionUnits().
|
|
*/
|
|
|
|
QSizeF QPageSize::definitionSize(PageSizeId pageSizeId)
|
|
{
|
|
if (pageSizeId == Custom)
|
|
return QSizeF();
|
|
return qt_definitionSize(pageSizeId);
|
|
}
|
|
|
|
/*!
|
|
Returns the definition units of the standard \a pageSizeId.
|
|
|
|
To obtain the definition size, call QPageSize::definitionSize().
|
|
*/
|
|
|
|
QPageSize::Unit QPageSize::definitionUnits(PageSizeId pageSizeId)
|
|
{
|
|
if (pageSizeId == Custom)
|
|
return Unit(-1);
|
|
return qt_pageSizes[pageSizeId].definitionUnits;
|
|
}
|
|
|
|
/*!
|
|
Returns the size of the standard \a pageSizeId in the requested \a units.
|
|
*/
|
|
|
|
QSizeF QPageSize::size(PageSizeId pageSizeId, Unit units)
|
|
{
|
|
if (pageSizeId == Custom)
|
|
return QSizeF();
|
|
return qt_unitSize(pageSizeId, units);
|
|
}
|
|
|
|
/*!
|
|
Returns the size of the standard \a pageSizeId in Points.
|
|
*/
|
|
|
|
QSize QPageSize::sizePoints(PageSizeId pageSizeId)
|
|
{
|
|
if (pageSizeId == Custom)
|
|
return QSize();
|
|
return QSize(qt_pageSizes[pageSizeId].widthPoints, qt_pageSizes[pageSizeId].heightPoints);
|
|
}
|
|
|
|
/*!
|
|
Returns the size of the standard \a pageSizeId in Device Pixels
|
|
for the given \a resolution.
|
|
*/
|
|
|
|
QSize QPageSize::sizePixels(PageSizeId pageSizeId, int resolution)
|
|
{
|
|
if (pageSizeId == Custom)
|
|
return QSize();
|
|
return qt_convertPointsToPixels(sizePoints(pageSizeId), resolution);
|
|
}
|
|
|
|
#ifndef QT_NO_DEBUG_STREAM
|
|
QDebug operator<<(QDebug dbg, const QPageSize &pageSize)
|
|
{
|
|
QDebugStateSaver saver(dbg);
|
|
dbg.nospace();
|
|
dbg.noquote();
|
|
dbg << "QPageSize(";
|
|
if (pageSize.isValid()) {
|
|
dbg << '"' << pageSize.name() << "\", key=\"" << pageSize.key()
|
|
<< "\", " << pageSize.sizePoints().width() << 'x'
|
|
<< pageSize.sizePoints().height() << "pt, id=" << pageSize.id();
|
|
} else {
|
|
dbg.nospace() << "QPageSize()";
|
|
}
|
|
dbg << ')';
|
|
return dbg;
|
|
}
|
|
#endif
|
|
|
|
QT_END_NAMESPACE
|