/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the either Technology Preview License Agreement or the
** Beta Release License Agreement.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain
** additional rights. These rights are described in the Nokia Qt LGPL
** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
** package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** If you are unsure which license is appropriate for your use, please
** contact the sales department at http://www.qtsoftware.com/contact.
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QT_NO_PRINTER
#include "qprinter_p.h"
#include "qprintengine_win_p.h"
#include <limits.h>
#include <private/qfont_p.h>
#include <private/qfontengine_p.h>
#include <private/qpainter_p.h>
#include <qbitmap.h>
#include <qdebug.h>
#include <qvector.h>
#include <qpicture.h>
#include <private/qpicture_p.h>
QT_BEGIN_NAMESPACE
extern QPainterPath qt_regionToPath(const QRegion ®ion);
// #define QT_DEBUG_DRAW
static void draw_text_item_win(const QPointF &_pos, const QTextItemInt &ti, HDC hdc,
bool convertToText, const QTransform &xform, const QPointF &topLeft);
static const struct {
int winSizeName;
QPrinter::PaperSize qtSizeName;
} dmMapping[] = {
{ DMPAPER_LETTER, QPrinter::Letter },
{ DMPAPER_LETTERSMALL, QPrinter::Letter },
{ DMPAPER_TABLOID, QPrinter::Tabloid },
{ DMPAPER_LEDGER, QPrinter::Ledger },
{ DMPAPER_LEGAL, QPrinter::Legal },
{ DMPAPER_EXECUTIVE, QPrinter::Executive },
{ DMPAPER_A3, QPrinter::A3 },
{ DMPAPER_A4, QPrinter::A4 },
{ DMPAPER_A4SMALL, QPrinter::A4 },
{ DMPAPER_A5, QPrinter::A5 },
{ DMPAPER_B4, QPrinter::B4 },
{ DMPAPER_B5, QPrinter::B5 },
{ DMPAPER_FOLIO, QPrinter::Folio },
{ DMPAPER_ENV_10, QPrinter::Comm10E },
{ DMPAPER_ENV_DL, QPrinter::DLE },
{ DMPAPER_ENV_C3, QPrinter::C5E },
{ DMPAPER_LETTER_EXTRA, QPrinter::Letter },
{ DMPAPER_LEGAL_EXTRA, QPrinter::Legal },
{ DMPAPER_TABLOID_EXTRA, QPrinter::Tabloid },
{ DMPAPER_A4_EXTRA, QPrinter::A4},
{ DMPAPER_LETTER_TRANSVERSE, QPrinter::Letter},
{ DMPAPER_A4_TRANSVERSE, QPrinter::A4},
{ DMPAPER_LETTER_EXTRA_TRANSVERSE, QPrinter::Letter },
{ DMPAPER_A_PLUS, QPrinter::A4 },
{ DMPAPER_B_PLUS, QPrinter::A3 },
{ DMPAPER_LETTER_PLUS, QPrinter::Letter },
{ DMPAPER_A4_PLUS, QPrinter::A4 },
{ DMPAPER_A5_TRANSVERSE, QPrinter::A5 },
{ DMPAPER_B5_TRANSVERSE, QPrinter::B5 },
{ DMPAPER_A3_EXTRA, QPrinter::A3 },
{ DMPAPER_A5_EXTRA, QPrinter::A5 },
{ DMPAPER_B5_EXTRA, QPrinter::B5 },
{ DMPAPER_A2, QPrinter::A2 },
{ DMPAPER_A3_TRANSVERSE, QPrinter::A3 },
{ DMPAPER_A3_EXTRA_TRANSVERSE,QPrinter::A3 },
{ 0, QPrinter::Custom }
};
QPrinter::PaperSize mapDevmodePaperSize(int s)
{
int i = 0;
while ((dmMapping[i].winSizeName > 0) && (dmMapping[i].winSizeName != s))
i++;
return dmMapping[i].qtSizeName;
}
static int mapPaperSizeDevmode(QPrinter::PaperSize s)
{
int i = 0;
while ((dmMapping[i].winSizeName > 0) && (dmMapping[i].qtSizeName != s))
i++;
return dmMapping[i].winSizeName;
}
static const struct {
int winSourceName;
QPrinter::PaperSource qtSourceName;
} sources[] = {
{ DMBIN_ONLYONE, QPrinter::OnlyOne },
{ DMBIN_LOWER, QPrinter::Lower },
{ DMBIN_MIDDLE, QPrinter::Middle },
{ DMBIN_MANUAL, QPrinter::Manual },
{ DMBIN_ENVELOPE, QPrinter::Envelope },
{ DMBIN_ENVMANUAL, QPrinter::EnvelopeManual },
{ DMBIN_AUTO, QPrinter::Auto },
{ DMBIN_TRACTOR, QPrinter::Tractor },
{ DMBIN_SMALLFMT, QPrinter::SmallFormat },
{ DMBIN_LARGEFMT, QPrinter::LargeFormat },
{ DMBIN_LARGECAPACITY, QPrinter::LargeCapacity },
{ DMBIN_CASSETTE, QPrinter::Cassette },
{ DMBIN_FORMSOURCE, QPrinter::FormSource },
{ 0, (QPrinter::PaperSource) -1 }
};
static QPrinter::PaperSource mapDevmodePaperSource(int s)
{
int i = 0;
while ((sources[i].winSourceName > 0) && (sources[i].winSourceName != s))
i++;
return sources[i].winSourceName ? sources[i].qtSourceName : (QPrinter::PaperSource) s;
}
static int mapPaperSourceDevmode(QPrinter::PaperSource s)
{
int i = 0;
while ((sources[i].qtSourceName >= 0) && (sources[i].qtSourceName != s))
i++;
return sources[i].winSourceName ? sources[i].winSourceName : s;
}
QWin32PrintEngine::QWin32PrintEngine(QPrinter::PrinterMode mode)
: QAlphaPaintEngine(*(new QWin32PrintEnginePrivate),
PaintEngineFeatures(PrimitiveTransform
| PixmapTransform
| PerspectiveTransform
| PainterPaths
| Antialiasing
| PaintOutsidePaintEvent))
{
Q_D(QWin32PrintEngine);
d->docName = QLatin1String("document1");
d->mode = mode;
d->queryDefault();
d->initialize();
}
bool QWin32PrintEngine::begin(QPaintDevice *pdev)
{
Q_D(QWin32PrintEngine);
QAlphaPaintEngine::begin(pdev);
if (!continueCall())
return true;
if (d->reinit) {
d->resetDC();
d->reinit = false;
}
// ### set default colors and stuff...
bool ok = d->state == QPrinter::Idle;
if (!d->hdc)
return false;
// Assign the FILE: to get the query...
if (d->printToFile && d->fileName.isEmpty())
d->fileName = d->port;
QT_WA({
d->devModeW()->dmCopies = d->num_copies;
DOCINFO di;
memset(&di, 0, sizeof(DOCINFO));
di.cbSize = sizeof(DOCINFO);
di.lpszDocName = reinterpret_cast<const wchar_t *>(d->docName.utf16());
if (d->printToFile && !d->fileName.isEmpty())
di.lpszOutput = reinterpret_cast<const wchar_t *>(d->fileName.utf16());
if (ok && StartDoc(d->hdc, &di) == SP_ERROR) {
qErrnoWarning("QWin32PrintEngine::begin: StartDoc failed");
ok = false;
}
} , {
d->devModeA()->dmCopies = d->num_copies;
DOCINFOA di;
memset(&di, 0, sizeof(DOCINFOA));
di.cbSize = sizeof(DOCINFOA);
QByteArray docNameA = d->docName.toLocal8Bit();
di.lpszDocName = docNameA.data();
QByteArray outfileA = d->fileName.toLocal8Bit();
if (d->printToFile && !d->fileName.isEmpty())
di.lpszOutput = outfileA;
if (ok && StartDocA(d->hdc, &di) == SP_ERROR) {
qErrnoWarning("QWin32PrintEngine::begin: StartDoc failed");
ok = false;
}
});
if (StartPage(d->hdc) <= 0) {
qErrnoWarning("QWin32PrintEngine::begin: StartPage failed");
ok = false;
}
if (!ok) {
d->state = QPrinter::Idle;
} else {
d->state = QPrinter::Active;
}
d->matrix = QTransform();
d->has_pen = true;
d->pen = QColor(Qt::black);
d->has_brush = false;
d->complex_xform = false;
updateMatrix(d->matrix);
if (!ok)
cleanUp();
return ok;
}
bool QWin32PrintEngine::end()
{
Q_D(QWin32PrintEngine);
if (d->hdc) {
if (d->state == QPrinter::Aborted) {
cleanUp();
AbortDoc(d->hdc);
return true;
}
}
QAlphaPaintEngine::end();
if (!continueCall())
return true;
if (d->hdc) {
EndPage(d->hdc); // end; printing done
EndDoc(d->hdc);
}
d->state = QPrinter::Idle;
d->reinit = true;
return true;
}
bool QWin32PrintEngine::newPage()
{
Q_D(QWin32PrintEngine);
Q_ASSERT(isActive());
Q_ASSERT(d->hdc);
flushAndInit();
bool transparent = GetBkMode(d->hdc) == TRANSPARENT;
if (!EndPage(d->hdc)) {
qErrnoWarning("QWin32PrintEngine::newPage: EndPage failed");
return false;
}
if (d->reinit) {
if (!d->resetDC()) {
qErrnoWarning("QWin32PrintEngine::newPage: ResetDC failed");
return false;
}
d->reinit = false;
}
if (!StartPage(d->hdc)) {
qErrnoWarning("Win32PrintEngine::newPage: StartPage failed");
return false;
}
SetTextAlign(d->hdc, TA_BASELINE);
if (transparent)
SetBkMode(d->hdc, TRANSPARENT);
// ###
return true;
bool success = false;
if (d->hdc && d->state == QPrinter::Active) {
// bool restorePainter = false;
// if ((qWinVersion()& Qt::WV_DOS_based) && painter && painter->isActive()) {
// painter->save(); // EndPage/StartPage ruins the DC
// restorePainter = true;
// }
if (EndPage(d->hdc) != SP_ERROR) {
// reinitialize the DC before StartPage if needed,
// because resetdc is disabled between calls to the StartPage and EndPage functions
// (see StartPage documentation in the Platform SDK:Windows GDI)
// state = PST_ACTIVEDOC;
// reinit();
// state = PST_ACTIVE;
// start the new page now
if (d->reinit) {
if (!d->resetDC())
qErrnoWarning("QWin32PrintEngine::newPage(), ResetDC failed (2)");
d->reinit = false;
}
success = (StartPage(d->hdc) != SP_ERROR);
}
if (!success)
d->state = QPrinter::Aborted;
// if (qWinVersion() & Qt::WV_DOS_based)
// if (restorePainter) {
// painter->restore();
// }
if (!success)
return false;
}
return true;
}
bool QWin32PrintEngine::abort()
{
// do nothing loop.
return false;
}
void QWin32PrintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
{
Q_D(const QWin32PrintEngine);
QAlphaPaintEngine::drawTextItem(p, textItem);
if (!continueCall())
return;
const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
QRgb brushColor = state->pen().brush().color().rgb();
bool fallBack = state->pen().brush().style() != Qt::SolidPattern
|| qAlpha(brushColor) != 0xff
|| QT_WA_INLINE(d->txop >= QTransform::TxProject, d->txop >= QTransform::TxScale)
|| ti.fontEngine->type() != QFontEngine::Win;
if (!fallBack) {
QFontEngineWin *fe = static_cast<QFontEngineWin *>(ti.fontEngine);
// Try selecting the font to see if we get a substitution font
SelectObject(d->hdc, fe->hfont);
if (GetDeviceCaps(d->hdc, TECHNOLOGY) != DT_CHARSTREAM) {
QT_WA({
TCHAR n[64];
GetTextFaceW(d->hdc, 64, n);
fallBack = QString::fromUtf16((ushort *)n)
!= QString::fromUtf16((ushort *)fe->logfont.lfFaceName);
} , {
char an[64];
GetTextFaceA(d->hdc, 64, an);
fallBack = QString::fromLocal8Bit(an)
!= QString::fromLocal8Bit(((LOGFONTA*)(&fe->logfont))->lfFaceName);
});
}
}
if (fallBack) {
QPaintEngine::drawTextItem(p, textItem);
return ;
}
// We only want to convert the glyphs to text if the entire string is latin1
bool latin1String = true;
for (int i=0; i < ti.num_chars; ++i) {
if (ti.chars[i].unicode() >= 0x100) {
latin1String = false;
break;
}
}
COLORREF cf = RGB(qRed(brushColor), qGreen(brushColor), qBlue(brushColor));
SelectObject(d->hdc, CreateSolidBrush(cf));
SelectObject(d->hdc, CreatePen(PS_SOLID, 1, cf));
SetTextColor(d->hdc, cf);
draw_text_item_win(p, ti, d->hdc, latin1String, d->matrix, d->devPaperRect.topLeft());
DeleteObject(SelectObject(d->hdc,GetStockObject(HOLLOW_BRUSH)));
DeleteObject(SelectObject(d->hdc,GetStockObject(BLACK_PEN)));
}
static inline qreal mmToInches(double mm)
{
return mm*0.039370147;
}
static inline qreal inchesToMM(double in)
{
return in/0.039370147;
}
int QWin32PrintEngine::metric(QPaintDevice::PaintDeviceMetric m) const
{
Q_D(const QWin32PrintEngine);
if (!d->hdc)
return 0;
int val;
int res = d->resolution;
switch (m) {
case QPaintDevice::PdmWidth:
if (d->has_custom_paper_size) {
val = qRound(d->paper_size.width() * res / 72.0);
} else {
int logPixelsX = GetDeviceCaps(d->hdc, LOGPIXELSX);
if (logPixelsX == 0) {
qWarning("QWin32PrintEngine::metric: GetDeviceCaps() failed, "
"might be a driver problem");
logPixelsX = 600; // Reasonable default
}
val = res
* GetDeviceCaps(d->hdc, d->fullPage ? PHYSICALWIDTH : HORZRES)
/ logPixelsX;
}
if (d->pageMarginsSet)
val -= int(mmToInches((d->previousDialogMargins.left() +
d->previousDialogMargins.width()) / 100.0) * res);
break;
case QPaintDevice::PdmHeight:
if (d->has_custom_paper_size) {
val = qRound(d->paper_size.height() * res / 72.0);
} else {
int logPixelsY = GetDeviceCaps(d->hdc, LOGPIXELSY);
if (logPixelsY == 0) {
qWarning("QWin32PrintEngine::metric: GetDeviceCaps() failed, "
"might be a driver problem");
logPixelsY = 600; // Reasonable default
}
val = res
* GetDeviceCaps(d->hdc, d->fullPage ? PHYSICALHEIGHT : VERTRES)
/ logPixelsY;
}
if (d->pageMarginsSet)
val -= int(mmToInches((d->previousDialogMargins.top() +
d->previousDialogMargins.height()) / 100.0) * res);
break;
case QPaintDevice::PdmDpiX:
val = res;
break;
case QPaintDevice::PdmDpiY:
val = res;
break;
case QPaintDevice::PdmPhysicalDpiX:
val = GetDeviceCaps(d->hdc, LOGPIXELSX);
break;
case QPaintDevice::PdmPhysicalDpiY:
val = GetDeviceCaps(d->hdc, LOGPIXELSY);
break;
case QPaintDevice::PdmWidthMM:
if (d->has_custom_paper_size) {
val = qRound(d->paper_size.width()*25.4/72);
} else {
if (!d->fullPage) {
val = GetDeviceCaps(d->hdc, HORZSIZE);
} else {
float wi = 25.4 * GetDeviceCaps(d->hdc, PHYSICALWIDTH);
int logPixelsX = GetDeviceCaps(d->hdc, LOGPIXELSX);
if (logPixelsX == 0) {
qWarning("QWin32PrintEngine::metric: GetDeviceCaps() failed, "
"might be a driver problem");
logPixelsX = 600; // Reasonable default
}
val = qRound(wi / logPixelsX);
}
}
if (d->pageMarginsSet)
val -= (d->previousDialogMargins.left() +
d->previousDialogMargins.width()) / 100.0;
break;
case QPaintDevice::PdmHeightMM:
if (d->has_custom_paper_size) {
val = qRound(d->paper_size.height()*25.4/72);
} else {
if (!d->fullPage) {
val = GetDeviceCaps(d->hdc, VERTSIZE);
} else {
float hi = 25.4 * GetDeviceCaps(d->hdc, PHYSICALHEIGHT);
int logPixelsY = GetDeviceCaps(d->hdc, LOGPIXELSY);
if (logPixelsY == 0) {
qWarning("QWin32PrintEngine::metric: GetDeviceCaps() failed, "
"might be a driver problem");
logPixelsY = 600; // Reasonable default
}
val = qRound(hi / logPixelsY);
}
}
if (d->pageMarginsSet)
val -= (d->previousDialogMargins.top() +
d->previousDialogMargins.height()) / 100.0;
break;
case QPaintDevice::PdmNumColors:
{
int bpp = GetDeviceCaps(d->hdc, BITSPIXEL);
if(bpp==32)
val = INT_MAX;
else if(bpp<=8)
val = GetDeviceCaps(d->hdc, NUMCOLORS);
else
val = 1 << (bpp * GetDeviceCaps(d->hdc, PLANES));
}
break;
case QPaintDevice::PdmDepth:
val = GetDeviceCaps(d->hdc, PLANES);
break;
default:
qWarning("QPrinter::metric: Invalid metric command");
return 0;
}
return val;
}
void QWin32PrintEngine::updateState(const QPaintEngineState &state)
{
Q_D(QWin32PrintEngine);
QAlphaPaintEngine::updateState(state);
if (!continueCall())
return;
if (state.state() & DirtyTransform) {
updateMatrix(state.transform());
}
if (state.state() & DirtyPen) {
d->pen = state.pen();
d->has_pen = d->pen.style() != Qt::NoPen && d->pen.isSolid();
}
if (state.state() & DirtyBrush) {
QBrush brush = state.brush();
d->has_brush = brush.style() == Qt::SolidPattern;
d->brush_color = brush.color();
}
if (state.state() & DirtyClipEnabled) {
if (state.isClipEnabled())
updateClipPath(painter()->clipPath(), Qt::ReplaceClip);
else
updateClipPath(QPainterPath(), Qt::NoClip);
}
if (state.state() & DirtyClipPath) {
updateClipPath(state.clipPath(), state.clipOperation());
}
if (state.state() & DirtyClipRegion) {
QRegion clipRegion = state.clipRegion();
QPainterPath clipPath = qt_regionToPath(clipRegion);
updateClipPath(clipPath, state.clipOperation());
}
}
void QWin32PrintEngine::updateClipPath(const QPainterPath &clipPath, Qt::ClipOperation op)
{
Q_D(QWin32PrintEngine);
bool doclip = true;
if (op == Qt::NoClip) {
SelectClipRgn(d->hdc, 0);
doclip = false;
}
if (doclip) {
QPainterPath xformed = clipPath * d->matrix;
if (xformed.isEmpty()) {
QRegion empty(-0x1000000, -0x1000000, 1, 1);
SelectClipRgn(d->hdc, empty.handle());
} else {
d->composeGdiPath(xformed);
const int ops[] = {
-1, // Qt::NoClip, covered above
RGN_COPY, // Qt::ReplaceClip
RGN_AND, // Qt::IntersectClip
RGN_OR // Qt::UniteClip
};
Q_ASSERT(op > 0 && unsigned(op) <= sizeof(ops) / sizeof(int));
SelectClipPath(d->hdc, ops[op]);
}
}
QPainterPath aclip = qt_regionToPath(alphaClipping());
if (!aclip.isEmpty()) {
QTransform tx(d->stretch_x, 0, 0, d->stretch_y, d->origin_x, d->origin_y);
d->composeGdiPath(tx.map(aclip));
SelectClipPath(d->hdc, RGN_DIFF);
}
}
void QWin32PrintEngine::updateMatrix(const QTransform &m)
{
Q_D(QWin32PrintEngine);
QTransform stretch(d->stretch_x, 0, 0, d->stretch_y, d->origin_x, d->origin_y);
d->painterMatrix = m;
d->matrix = d->painterMatrix * stretch;
d->txop = d->matrix.type();
d->complex_xform = (d->txop > QTransform::TxScale);
}
void QWin32PrintEngine::drawPixmap(const QRectF &targetRect,
const QPixmap &originalPixmap,
const QRectF &sourceRect)
{
Q_D(QWin32PrintEngine);
QAlphaPaintEngine::drawPixmap(targetRect, originalPixmap, sourceRect);
if (!continueCall())
return;
const int tileSize = 2048;
QRectF r = targetRect;
QRectF sr = sourceRect;
QPixmap pixmap = originalPixmap;
if (sr.size() != pixmap.size()) {
pixmap = pixmap.copy(sr.toRect());
}
qreal scaleX = 1.0f;
qreal scaleY = 1.0f;
QTransform scaleMatrix = QTransform::fromScale(r.width() / pixmap.width(), r.height() / pixmap.height());
QTransform adapted = QPixmap::trueMatrix(d->painterMatrix * scaleMatrix,
pixmap.width(), pixmap.height());
qreal xform_offset_x = adapted.dx();
qreal xform_offset_y = adapted.dy();
if (d->complex_xform) {
pixmap = pixmap.transformed(adapted);
scaleX = d->stretch_x;
scaleY = d->stretch_y;
} else {
scaleX = d->stretch_x * (r.width() / pixmap.width()) * d->painterMatrix.m11();
scaleY = d->stretch_y * (r.height() / pixmap.height()) * d->painterMatrix.m22();
}
QPointF topLeft = r.topLeft() * d->painterMatrix;
int tx = int(topLeft.x() * d->stretch_x + d->origin_x);
int ty = int(topLeft.y() * d->stretch_y + d->origin_y);
int tw = qAbs(int(pixmap.width() * scaleX));
int th = qAbs(int(pixmap.height() * scaleY));
xform_offset_x *= d->stretch_x;
xform_offset_y *= d->stretch_y;
int dc_state = SaveDC(d->hdc);
int tilesw = pixmap.width() / tileSize;
int tilesh = pixmap.height() / tileSize;
++tilesw;
++tilesh;
int txinc = tileSize*scaleX;
int tyinc = tileSize*scaleY;
for (int y = 0; y < tilesh; ++y) {
int tposy = ty + (y * tyinc);
int imgh = tileSize;
int height = tyinc;
if (y == (tilesh - 1)) {
imgh = pixmap.height() - (y * tileSize);
height = (th - (y * tyinc));
}
for (int x = 0; x < tilesw; ++x) {
int tposx = tx + (x * txinc);
int imgw = tileSize;
int width = txinc;
if (x == (tilesw - 1)) {
imgw = pixmap.width() - (x * tileSize);
width = (tw - (x * txinc));
}
QPixmap p = pixmap.copy(tileSize * x, tileSize * y, imgw, imgh);
HBITMAP hbitmap = p.toWinHBITMAP(QPixmap::NoAlpha);
HDC display_dc = GetDC(0);
HDC hbitmap_hdc = CreateCompatibleDC(display_dc);
HGDIOBJ null_bitmap = SelectObject(hbitmap_hdc, hbitmap);
ReleaseDC(0, display_dc);
if (!StretchBlt(d->hdc, qRound(tposx - xform_offset_x), qRound(tposy - xform_offset_y), width, height,
hbitmap_hdc, 0, 0, p.width(), p.height(), SRCCOPY))
qErrnoWarning("QWin32PrintEngine::drawPixmap, StretchBlt failed");
SelectObject(hbitmap_hdc, null_bitmap);
DeleteObject(hbitmap);
DeleteDC(hbitmap_hdc);
}
}
RestoreDC(d->hdc, dc_state);
}
void QWin32PrintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pm, const QPointF &pos)
{
Q_D(QWin32PrintEngine);
QAlphaPaintEngine::drawTiledPixmap(r, pm, pos);
if (!continueCall())
return;
if (d->complex_xform || !pos.isNull()) {
QPaintEngine::drawTiledPixmap(r, pm, pos);
} else {
int dc_state = SaveDC(d->hdc);
HDC display_dc = GetDC(0);
HBITMAP hbitmap = pm.toWinHBITMAP(QPixmap::NoAlpha);
HDC hbitmap_hdc = CreateCompatibleDC(display_dc);
HGDIOBJ null_bitmap = SelectObject(hbitmap_hdc, hbitmap);
ReleaseDC(0, display_dc);
QRectF trect = d->painterMatrix.mapRect(r);
int tx = int(trect.left() * d->stretch_x + d->origin_x);
int ty = int(trect.top() * d->stretch_y + d->origin_y);
int xtiles = int(trect.width() / pm.width()) + 1;
int ytiles = int(trect.height() / pm.height()) + 1;
int xinc = int(pm.width() * d->stretch_x);
int yinc = int(pm.height() * d->stretch_y);
for (int y = 0; y < ytiles; ++y) {
int ity = ty + (yinc * y);
int ith = pm.height();
if (y == (ytiles - 1)) {
ith = int(trect.height() - (pm.height() * y));
}
for (int x = 0; x < xtiles; ++x) {
int itx = tx + (xinc * x);
int itw = pm.width();
if (x == (xtiles - 1)) {
itw = int(trect.width() - (pm.width() * x));
}
if (!StretchBlt(d->hdc, itx, ity, int(itw * d->stretch_x), int(ith * d->stretch_y),
hbitmap_hdc, 0, 0, itw, ith, SRCCOPY))
qErrnoWarning("QWin32PrintEngine::drawPixmap, StretchBlt failed");
}
}
SelectObject(hbitmap_hdc, null_bitmap);
DeleteObject(hbitmap);
DeleteDC(hbitmap_hdc);
RestoreDC(d->hdc, dc_state);
}
}
void QWin32PrintEnginePrivate::composeGdiPath(const QPainterPath &path)
{
if (!BeginPath(hdc))
qErrnoWarning("QWin32PrintEnginePrivate::drawPath: BeginPath failed");
// Drawing the subpaths
int start = -1;
for (int i=0; i<path.elementCount(); ++i) {
const QPainterPath::Element &elm = path.elementAt(i);
switch (elm.type) {
case QPainterPath::MoveToElement:
if (start >= 0
&& path.elementAt(start).x == path.elementAt(i-1).x
&& path.elementAt(start).y == path.elementAt(i-1).y)
CloseFigure(hdc);
start = i;
MoveToEx(hdc, qRound(elm.x), qRound(elm.y), 0);
break;
case QPainterPath::LineToElement:
LineTo(hdc, qRound(elm.x), qRound(elm.y));
break;
case QPainterPath::CurveToElement: {
POINT pts[3] = {
{ qRound(elm.x), qRound(elm.y) },
{ qRound(path.elementAt(i+1).x), qRound(path.elementAt(i+1).y) },
{ qRound(path.elementAt(i+2).x), qRound(path.elementAt(i+2).y) }
};
i+=2;
PolyBezierTo(hdc, pts, 3);
break;
}
default:
qFatal("QWin32PaintEngine::drawPath: Unhandled type: %d", elm.type);
}
}
if (start >= 0
&& path.elementAt(start).x == path.elementAt(path.elementCount()-1).x
&& path.elementAt(start).y == path.elementAt(path.elementCount()-1).y)
CloseFigure(hdc);
if (!EndPath(hdc))
qErrnoWarning("QWin32PaintEngine::drawPath: EndPath failed");
SetPolyFillMode(hdc, path.fillRule() == Qt::WindingFill ? WINDING : ALTERNATE);
}
void QWin32PrintEnginePrivate::fillPath_dev(const QPainterPath &path, const QColor &color)
{
#ifdef QT_DEBUG_DRAW
qDebug() << " --- QWin32PrintEnginePrivate::fillPath() bound:" << path.boundingRect() << color;
#endif
composeGdiPath(path);
HBRUSH brush = CreateSolidBrush(RGB(color.red(), color.green(), color.blue()));
HGDIOBJ old_brush = SelectObject(hdc, brush);
FillPath(hdc);
DeleteObject(SelectObject(hdc, old_brush));
}
void QWin32PrintEnginePrivate::strokePath_dev(const QPainterPath &path, const QColor &color, qreal penWidth)
{
composeGdiPath(path);
LOGBRUSH brush;
brush.lbStyle = BS_SOLID;
brush.lbColor = RGB(color.red(), color.green(), color.blue());
DWORD capStyle = PS_ENDCAP_SQUARE;
DWORD joinStyle = PS_JOIN_BEVEL;
if (pen.capStyle() == Qt::FlatCap)
capStyle = PS_ENDCAP_FLAT;
else if (pen.capStyle() == Qt::RoundCap)
capStyle = PS_ENDCAP_ROUND;
if (pen.joinStyle() == Qt::MiterJoin)
joinStyle = PS_JOIN_MITER;
else if (pen.joinStyle() == Qt::RoundJoin)
joinStyle = PS_JOIN_ROUND;
HPEN pen = ExtCreatePen(((penWidth == 0) ? PS_COSMETIC : PS_GEOMETRIC)
| PS_SOLID | capStyle | joinStyle,
penWidth, &brush, 0, 0);
HGDIOBJ old_pen = SelectObject(hdc, pen);
StrokePath(hdc);
DeleteObject(SelectObject(hdc, old_pen));
}
void QWin32PrintEnginePrivate::fillPath(const QPainterPath &path, const QColor &color)
{
fillPath_dev(path * matrix, color);
}
void QWin32PrintEnginePrivate::strokePath(const QPainterPath &path, const QColor &color)
{
QPainterPathStroker stroker;
if (pen.style() == Qt::CustomDashLine) {
stroker.setDashPattern(pen.dashPattern());
stroker.setDashOffset(pen.dashOffset());
} else {
stroker.setDashPattern(pen.style());
}
stroker.setCapStyle(pen.capStyle());
stroker.setJoinStyle(pen.joinStyle());
stroker.setMiterLimit(pen.miterLimit());
QPainterPath stroke;
qreal width = pen.widthF();
if (pen.style() == Qt::SolidLine && (pen.isCosmetic() || matrix.type() < QTransform::TxScale)) {
strokePath_dev(path * matrix, color, width);
} else {
stroker.setWidth(width);
if (pen.isCosmetic()) {
stroke = stroker.createStroke(path * matrix);
} else {
stroke = stroker.createStroke(path) * painterMatrix;
QTransform stretch(stretch_x, 0, 0, stretch_y, origin_x, origin_y);
stroke = stroke * stretch;
}
if (stroke.isEmpty())
return;
fillPath_dev(stroke, color);
}
}
void QWin32PrintEngine::drawPath(const QPainterPath &path)
{
#ifdef QT_DEBUG_DRAW
qDebug() << " - QWin32PrintEngine::drawPath(), bounds: " << path.boundingRect();
#endif
Q_D(QWin32PrintEngine);
QAlphaPaintEngine::drawPath(path);
if (!continueCall())
return;
if (d->has_brush)
d->fillPath(path, d->brush_color);
if (d->has_pen)
d->strokePath(path, d->pen.color());
}
void QWin32PrintEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
{
#ifdef QT_DEBUG_DRAW
qDebug() << " - QWin32PrintEngine::drawPolygon(), pointCount: " << pointCount;
#endif
QAlphaPaintEngine::drawPolygon(points, pointCount, mode);
if (!continueCall())
return;
Q_ASSERT(pointCount > 1);
QPainterPath path(points[0]);
for (int i=1; i<pointCount; ++i) {
path.lineTo(points[i]);
}
Q_D(QWin32PrintEngine);
bool has_brush = d->has_brush;
if (mode == PolylineMode)
d->has_brush = false; // No brush for polylines
else
path.closeSubpath(); // polygons are should always be closed.
drawPath(path);
d->has_brush = has_brush;
}
void QWin32PrintEnginePrivate::queryDefault()
{
/* Read the default printer name, driver and port with the intuitive function
* Strings "windows" and "device" are specified in the MSDN under EnumPrinters()
*/
QString noPrinters(QLatin1String("qt_no_printers"));
QString output;
QT_WA({
ushort buffer[256];
GetProfileStringW(L"windows", L"device",
reinterpret_cast<const wchar_t *>(noPrinters.utf16()),
reinterpret_cast<wchar_t *>(buffer), 256);
output = QString::fromUtf16(buffer);
if (output.isEmpty() || output == noPrinters) // no printers
return;
}, {
char buffer[256];
GetProfileStringA("windows", "device", noPrinters.toLatin1(), buffer, 256);
output = QString::fromLocal8Bit(buffer);
if (output.isEmpty() || output == noPrinters) // no printers
return;
});
QStringList info = output.split(QLatin1Char(','));
if (info.size() > 0) {
if (name.isEmpty())
name = info.at(0);
if (program.isEmpty())
program = info.at(1);
if (port.isEmpty())
port = info.at(2);
}
}
QWin32PrintEnginePrivate::~QWin32PrintEnginePrivate()
{
if (hdc)
release();
}
void QWin32PrintEnginePrivate::initialize()
{
if (hdc)
release();
Q_ASSERT(!hPrinter);
Q_ASSERT(!hdc);
Q_ASSERT(!devMode);
Q_ASSERT(!pInfo);
if (name.isEmpty())
return;
txop = QTransform::TxNone;
bool ok;
QT_WA( {
ok = OpenPrinterW((LPWSTR)name.utf16(), (LPHANDLE)&hPrinter, 0);
}, {
ok = OpenPrinterA((LPSTR)name.toLatin1().data(), (LPHANDLE)&hPrinter, 0);
} );
if (!ok) {
qErrnoWarning("QWin32PrintEngine::initialize: OpenPrinter failed");
return;
}
// Fetch the PRINTER_INFO_2 with DEVMODE data containing the
// printer settings.
DWORD infoSize, numBytes;
ok = true;
QT_WA( {
GetPrinterW(hPrinter, 2, NULL, 0, &infoSize);
hMem = GlobalAlloc(GHND, infoSize);
pInfo = GlobalLock(hMem);
if (!GetPrinterW(hPrinter, 2, (LPBYTE)pInfo, infoSize, &numBytes)) {
ok = false;
}
}, {
GetPrinterA(hPrinter, 2, NULL, 0, &infoSize);
hMem = GlobalAlloc(GHND, infoSize);
pInfo = GlobalLock(hMem);
if (!GetPrinterA(hPrinter, 2, (LPBYTE)pInfo, infoSize, &numBytes)) {
ok = false;
}
});
if (!ok) {
qErrnoWarning("QWin32PrintEngine::initialize: GetPrinter failed");
GlobalUnlock(pInfo);
GlobalFree(hMem);
ClosePrinter(hPrinter);
pInfo = 0;
hMem = 0;
hPrinter = 0;
return;
}
QT_WA( {
devMode = pInfoW()->pDevMode;
}, {
devMode = pInfoA()->pDevMode;
} );
QT_WA( {
hdc = CreateDC(reinterpret_cast<const wchar_t *>(program.utf16()),
reinterpret_cast<const wchar_t *>(name.utf16()), 0, devModeW());
}, {
hdc = CreateDCA(program.toLatin1(), name.toLatin1(), 0, devModeA());
} );
Q_ASSERT(hPrinter);
Q_ASSERT(pInfo);
if (devMode) {
QT_WA( {
num_copies = devModeW()->dmCopies;
}, {
num_copies = devModeA()->dmCopies;
} );
}
initHDC();
#ifdef QT_DEBUG_DRAW
qDebug() << "QWin32PrintEngine::initialize()" << endl
<< " - paperRect" << devPaperRect << endl
<< " - pageRect" << devPageRect << endl
<< " - stretch_x" << stretch_x << endl
<< " - stretch_y" << stretch_y << endl
<< " - origin_x" << origin_x << endl
<< " - origin_y" << origin_y << endl;
#endif
}
void QWin32PrintEnginePrivate::initHDC()
{
Q_ASSERT(hdc);
HDC display_dc = GetDC(0);
dpi_x = GetDeviceCaps(hdc, LOGPIXELSX);
dpi_y = GetDeviceCaps(hdc, LOGPIXELSY);
dpi_display = GetDeviceCaps(display_dc, LOGPIXELSY);
ReleaseDC(0, display_dc);
if (dpi_display == 0) {
qWarning("QWin32PrintEngine::metric: GetDeviceCaps() failed, "
"might be a driver problem");
dpi_display = 96; // Reasonable default
}
switch(mode) {
case QPrinter::ScreenResolution:
resolution = dpi_display;
stretch_x = dpi_x / double(dpi_display);
stretch_y = dpi_y / double(dpi_display);
break;
case QPrinter::PrinterResolution:
case QPrinter::HighResolution:
resolution = dpi_y;
stretch_x = 1;
stretch_y = 1;
break;
default:
break;
}
initDevRects();
}
void QWin32PrintEnginePrivate::initDevRects()
{
devPaperRect = QRect(0, 0,
GetDeviceCaps(hdc, PHYSICALWIDTH),
GetDeviceCaps(hdc, PHYSICALHEIGHT));
devPhysicalPageRect = QRect(GetDeviceCaps(hdc, PHYSICALOFFSETX),
GetDeviceCaps(hdc, PHYSICALOFFSETY),
GetDeviceCaps(hdc, HORZRES),
GetDeviceCaps(hdc, VERTRES));
if (!pageMarginsSet)
devPageRect = devPhysicalPageRect;
else
devPageRect = devPaperRect.adjusted(qRound(mmToInches(previousDialogMargins.left() / 100.0) * dpi_x),
qRound(mmToInches(previousDialogMargins.top() / 100.0) * dpi_y),
-qRound(mmToInches(previousDialogMargins.width() / 100.0) * dpi_x),
-qRound(mmToInches(previousDialogMargins.height() / 100.0) * dpi_y));
updateOrigin();
}
void QWin32PrintEnginePrivate::setPageMargins(int marginLeft, int marginTop, int marginRight, int marginBottom)
{
pageMarginsSet = true;
previousDialogMargins = QRect(marginLeft, marginTop, marginRight, marginBottom);
devPageRect = devPaperRect.adjusted(qRound(mmToInches(marginLeft / 100.0) * dpi_x),
qRound(mmToInches(marginTop / 100.0) * dpi_y),
- qRound(mmToInches(marginRight / 100.0) * dpi_x),
- qRound(mmToInches(marginBottom / 100.0) * dpi_y));
updateOrigin();
}
QRect QWin32PrintEnginePrivate::getPageMargins() const
{
if (pageMarginsSet)
return previousDialogMargins;
else
return QRect(qRound(inchesToMM(devPhysicalPageRect.left()) * 100.0 / dpi_x),
qRound(inchesToMM(devPhysicalPageRect.top()) * 100.0 / dpi_y),
qRound(inchesToMM(devPaperRect.right() - devPhysicalPageRect.right()) * 100.0 / dpi_x),
qRound(inchesToMM(devPaperRect.bottom() - devPhysicalPageRect.bottom()) * 100.0 / dpi_y));
}
void QWin32PrintEnginePrivate::release()
{
if (hdc == 0)
return;
if (globalDevMode) { // Devmode comes from print dialog
GlobalUnlock(globalDevMode);
} else { // Devmode comes from initialize...
// devMode is a part of the same memory block as pInfo so one free is enough...
GlobalUnlock(hMem);
GlobalFree(hMem);
}
if (hPrinter)
ClosePrinter(hPrinter);
DeleteDC(hdc);
hdc = 0;
hPrinter = 0;
pInfo = 0;
hMem = 0;
devMode = 0;
}
QList<QVariant> QWin32PrintEnginePrivate::queryResolutions() const
{
// Read the supported resolutions of the printer.
DWORD numRes;
LONG *enumRes;
DWORD errRes;
QList<QVariant> list;
QT_WA({
numRes = DeviceCapabilities(reinterpret_cast<const wchar_t *>(name.utf16()),
reinterpret_cast<const wchar_t *>(port.utf16()),
DC_ENUMRESOLUTIONS, 0, 0);
if (numRes == (DWORD)-1)
return list;
enumRes = (LONG*)malloc(numRes * 2 * sizeof(LONG));
errRes = DeviceCapabilities(reinterpret_cast<const wchar_t *>(name.utf16()),
reinterpret_cast<const wchar_t *>(port.utf16()),
DC_ENUMRESOLUTIONS, (LPWSTR)enumRes, 0);
}, {
numRes = DeviceCapabilitiesA(name.toLocal8Bit(), port.toLocal8Bit(), DC_ENUMRESOLUTIONS, 0, 0);
if (numRes == (DWORD)-1)
return list;
enumRes = (LONG*)malloc(numRes * 2 * sizeof(LONG));
errRes = DeviceCapabilitiesA(name.toLocal8Bit(), port.toLocal8Bit(), DC_ENUMRESOLUTIONS, (LPSTR)enumRes, 0);
});
if (errRes == (DWORD)-1) {
qErrnoWarning("QWin32PrintEngine::queryResolutions: DeviceCapabilities failed");
return list;
}
for (uint i=0; i<numRes; ++i)
list.append(int(enumRes[i*2]));
return list;
}
void QWin32PrintEnginePrivate::doReinit()
{
if (state == QPrinter::Active) {
reinit = true;
} else {
resetDC();
initDevRects();
reinit = false;
}
}
void QWin32PrintEnginePrivate::updateOrigin()
{
if (fullPage) {
// subtract physical margins to make (0,0) absolute top corner of paper
// then add user defined margins
origin_x = -devPhysicalPageRect.x();
origin_y = -devPhysicalPageRect.y();
if (pageMarginsSet) {
origin_x += devPageRect.left();
origin_y += devPageRect.top();
}
} else {
origin_x = 0;
origin_y = 0;
if (pageMarginsSet) {
origin_x = devPageRect.left() - devPhysicalPageRect.x();
origin_y = devPageRect.top() - devPhysicalPageRect.y();
}
}
}
void QWin32PrintEngine::setProperty(PrintEnginePropertyKey key, const QVariant &value)
{
Q_D(QWin32PrintEngine);
switch (key) {
case PPK_CollateCopies:
{
if (!d->devMode)
break;
short collate = value.toBool() ? DMCOLLATE_TRUE : DMCOLLATE_FALSE;
QT_WA( { d->devModeW()->dmCollate = collate; },
{ d->devModeA()->dmCollate = collate; } );
d->doReinit();
}
break;
case PPK_ColorMode:
{
if (!d->devMode)
break;
int cm = value.toInt() == QPrinter::Color ? DMCOLOR_COLOR : DMCOLOR_MONOCHROME;
QT_WA( { d->devModeW()->dmColor = cm; }, { d->devModeA()->dmColor = cm; } );
d->doReinit();
}
break;
case PPK_Creator:
break;
case PPK_DocumentName:
if (isActive()) {
qWarning("QWin32PrintEngine: Cannot change document name while printing is active");
return;
}
d->docName = value.toString();
break;
case PPK_FullPage:
d->fullPage = value.toBool();
d->updateOrigin();
break;
case PPK_NumberOfCopies:
if (!d->devMode)
break;
d->num_copies = value.toInt();
QT_WA( { d->devModeW()->dmCopies = d->num_copies; },
{ d->devModeA()->dmCopies = d->num_copies; });
d->doReinit();
break;
case PPK_Orientation:
{
if (!d->devMode)
break;
int orientation = value.toInt() == QPrinter::Landscape ? DMORIENT_LANDSCAPE : DMORIENT_PORTRAIT;
int old_orientation;
QT_WA( {
old_orientation = d->devModeW()->dmOrientation;
d->devModeW()->dmOrientation = orientation;
}, {
old_orientation = d->devModeA()->dmOrientation;
d->devModeA()->dmOrientation = orientation;
} );
if (d->has_custom_paper_size && old_orientation != orientation)
d->paper_size = QSizeF(d->paper_size.height(), d->paper_size.width());
d->doReinit();
}
break;
case PPK_OutputFileName:
if (isActive()) {
qWarning("QWin32PrintEngine: Cannot change filename while printing");
} else {
d->fileName = value.toString();
d->printToFile = !value.toString().isEmpty();
}
break;
case PPK_PaperSize:
if (!d->devMode)
break;
QT_WA( {
d->devModeW()->dmPaperSize = mapPaperSizeDevmode(QPrinter::PaperSize(value.toInt()));
}, {
d->devModeA()->dmPaperSize = mapPaperSizeDevmode(QPrinter::PaperSize(value.toInt()));
} );
d->has_custom_paper_size = (QPrinter::PaperSize(value.toInt()) == QPrinter::Custom);
d->doReinit();
break;
case PPK_PaperSource:
{
if (!d->devMode)
break;
int dmMapped = DMBIN_AUTO;
QList<QVariant> v = property(PPK_PaperSources).toList();
if (v.contains(value))
dmMapped = mapPaperSourceDevmode(QPrinter::PaperSource(value.toInt()));
QT_WA( {
d->devModeW()->dmDefaultSource = dmMapped;
}, {
d->devModeA()->dmDefaultSource = dmMapped;
} );
d->doReinit();
}
break;
case PPK_PrinterName:
d->name = value.toString();
if(d->name.isEmpty())
d->queryDefault();
d->initialize();
break;
case PPK_Resolution:
{
d->resolution = value.toInt();
d->stretch_x = d->dpi_x / double(d->resolution);
d->stretch_y = d->dpi_y / double(d->resolution);
}
break;
case PPK_SelectionOption:
break;
case PPK_SupportedResolutions:
break;
case PPK_WindowsPageSize:
if (!d->devMode)
break;
d->has_custom_paper_size = false;
QT_WA( {
d->devModeW()->dmPaperSize = value.toInt();
}, {
d->devModeA()->dmPaperSize = value.toInt();
} );
d->doReinit();
break;
case PPK_CustomPaperSize:
{
d->has_custom_paper_size = true;
d->paper_size = value.toSizeF();
if (!d->devMode)
break;
int orientation;
QT_WA( {
orientation = d->devModeW()->dmOrientation;
DWORD needed = 0;
DWORD returned = 0;
if (!EnumForms(d->hPrinter, 1, 0, 0, &needed, &returned)) {
BYTE *forms = (BYTE *) malloc(needed);
if (EnumForms(d->hPrinter, 1, forms, needed, &needed, &returned)) {
for (DWORD i=0; i< returned; ++i) {
FORM_INFO_1 *formArray = reinterpret_cast<FORM_INFO_1 *>(forms);
// the form sizes are specified in 1000th of a mm,
// convert the size to Points
QSizeF size((formArray[i].Size.cx * 72/25.4)/1000.0,
(formArray[i].Size.cy * 72/25.4)/1000.0);
if (qAbs(d->paper_size.width() - size.width()) <= 2
&& qAbs(d->paper_size.height() - size.height()) <= 2)
{
d->devModeW()->dmPaperSize = i+1;
break;
}
}
}
free(forms);
}
}, {
orientation = d->devModeA()->dmOrientation;
} );
if (orientation != DMORIENT_PORTRAIT)
d->paper_size = QSizeF(d->paper_size.height(), d->paper_size.width());
break;
}
case PPK_PageMargins:
{
QList<QVariant> margins(value.toList());
Q_ASSERT(margins.size() == 4);
int left, top, right, bottom;
// specified in 1/100 mm
left = (margins.at(0).toDouble()*25.4/72.0) * 100;
top = (margins.at(1).toDouble()*25.4/72.0) * 100;
right = (margins.at(2).toDouble()*25.4/72.0) * 100;
bottom = (margins.at(3).toDouble()*25.4/72.0) * 100;
d->setPageMargins(left, top, right, bottom);
break;
}
default:
// Do nothing
break;
}
}
QVariant QWin32PrintEngine::property(PrintEnginePropertyKey key) const
{
Q_D(const QWin32PrintEngine);
QVariant value;
switch (key) {
case PPK_CollateCopies:
value = false;
break;
case PPK_ColorMode:
{
if (!d->devMode) {
value = QPrinter::Color;
} else {
int mode;
QT_WA( {
mode = d->devModeW()->dmColor;
}, {
mode = d->devModeA()->dmColor;
} );
value = mode == DMCOLOR_COLOR ? QPrinter::Color : QPrinter::GrayScale;
}
}
break;
case PPK_DocumentName:
value = d->docName;
break;
case PPK_FullPage:
value = d->fullPage;
break;
case PPK_NumberOfCopies:
value = 1;
break;
case PPK_Orientation:
{
if (!d->devMode) {
value = QPrinter::Portrait;
} else {
int o;
QT_WA( { o = d->devModeW()->dmOrientation; }, { o = d->devModeA()->dmOrientation; } );
value = o == DMORIENT_LANDSCAPE ? QPrinter::Landscape : QPrinter::Portrait;
}
}
break;
case PPK_OutputFileName:
value = d->fileName;
break;
case PPK_PageRect:
if (d->has_custom_paper_size) {
QRect rect(0, 0,
qRound(d->paper_size.width() * d->resolution / 72.0),
qRound(d->paper_size.height() * d->resolution / 72.0));
if (d->pageMarginsSet) {
rect = rect.adjusted(qRound(mmToInches(d->previousDialogMargins.left()/100.0) * d->resolution),
qRound(mmToInches(d->previousDialogMargins.top()/100.0) * d->resolution),
-qRound(mmToInches(d->previousDialogMargins.width()/100.0) * d->resolution),
-qRound(mmToInches(d->previousDialogMargins.height()/100.0) * d->resolution));
}
value = rect;
} else {
value = QTransform(1/d->stretch_x, 0, 0, 1/d->stretch_y, 0, 0)
.mapRect(d->fullPage ? d->devPhysicalPageRect : d->devPageRect);
}
break;
case PPK_PaperSize:
if (d->has_custom_paper_size) {
value = QPrinter::Custom;
} else {
if (!d->devMode) {
value = QPrinter::A4;
} else {
QT_WA( {
value = mapDevmodePaperSize(d->devModeW()->dmPaperSize);
}, {
value = mapDevmodePaperSize(d->devModeA()->dmPaperSize);
} );
}
}
break;
case PPK_PaperRect:
if (d->has_custom_paper_size) {
value = QRect(0, 0,
qRound(d->paper_size.width() * d->resolution / 72.0),
qRound(d->paper_size.height() * d->resolution / 72.0));
} else {
value = QTransform(1/d->stretch_x, 0, 0, 1/d->stretch_y, 0, 0).mapRect(d->devPaperRect);
}
break;
case PPK_PaperSource:
if (!d->devMode) {
value = QPrinter::Auto;
} else {
QT_WA( {
value = mapDevmodePaperSource(d->devModeW()->dmDefaultSource);
}, {
value = mapDevmodePaperSource(d->devModeA()->dmDefaultSource);
} );
}
break;
case PPK_PrinterName:
value = d->name;
break;
case PPK_Resolution:
if (d->resolution || !d->name.isEmpty())
value = d->resolution;
break;
case PPK_SupportedResolutions:
value = d->queryResolutions();
break;
case PPK_WindowsPageSize:
if (!d->devMode) {
value = -1;
} else {
QT_WA( {
value = d->devModeW()->dmPaperSize;
}, {
value = d->devModeA()->dmPaperSize;
} );
}
break;
case PPK_PaperSources:
{
int available, count;
WORD *data;
QT_WA({
available = DeviceCapabilitiesW((const WCHAR *)d->name.utf16(), (const WCHAR *)d->port.utf16(), DC_BINS, 0,
d->devModeW());
}, {
available = DeviceCapabilitiesA(d->name.toLatin1(), d->port.toLatin1(), DC_BINS, 0,
d->devModeA());
});
if (available <= 0)
break;
data = (WORD *) malloc(available * sizeof(WORD));
QT_WA({
count = DeviceCapabilitiesW((const WCHAR *)d->name.utf16(), (const WCHAR *)d->port.utf16(), DC_BINS, (WCHAR *)data,
d->devModeW());
}, {
count = DeviceCapabilitiesA(d->name.toLatin1(), d->port.toLatin1(), DC_BINS,
(char *) data, d->devModeA());
});
QList<QVariant> out;
for (int i=0; i<count; ++i) {
QPrinter::PaperSource src = mapDevmodePaperSource(data[i]);
if (src != -1)
out << (int) src;
}
value = out;
free(data);
}
break;
case PPK_CustomPaperSize:
value = d->paper_size;
break;
case PPK_PageMargins:
{
QList<QVariant> margins;
QRect pageMargins(d->getPageMargins());
// specified in 1/100 mm
margins << (mmToInches(pageMargins.left()/100.0) * 72)
<< (mmToInches(pageMargins.top()/100.0) * 72)
<< (mmToInches(pageMargins.width()/100.0) * 72)
<< (mmToInches(pageMargins.height()/100.0) * 72);
value = margins;
break;
}
default:
// Do nothing
break;
}
return value;
}
QPrinter::PrinterState QWin32PrintEngine::printerState() const
{
return d_func()->state;
}
HDC QWin32PrintEngine::getDC() const
{
return d_func()->hdc;
}
void QWin32PrintEngine::releaseDC(HDC) const
{
}
HGLOBAL *QWin32PrintEnginePrivate::createDevNames()
{
QT_WA( {
int size = sizeof(DEVNAMES)
+ program.length() * 2 + 2
+ name.length() * 2 + 2
+ port.length() * 2 + 2;
HGLOBAL *hGlobal = (HGLOBAL *) GlobalAlloc(GMEM_MOVEABLE, size);
DEVNAMES *dn = (DEVNAMES*) GlobalLock(hGlobal);
dn->wDriverOffset = sizeof(DEVNAMES) / sizeof(TCHAR);
dn->wDeviceOffset = dn->wDriverOffset + program.length() + 1;
dn->wOutputOffset = dn->wDeviceOffset + name.length() + 1;
memcpy((ushort*)dn + dn->wDriverOffset, program.utf16(), program.length() * 2 + 2);
memcpy((ushort*)dn + dn->wDeviceOffset, name.utf16(), name.length() * 2 + 2);
memcpy((ushort*)dn + dn->wOutputOffset, port.utf16(), port.length() * 2 + 2);
dn->wDefault = 0;
GlobalUnlock(hGlobal);
// printf("QPrintDialogWinPrivate::createDevNames()\n"
// " -> wDriverOffset: %d\n"
// " -> wDeviceOffset: %d\n"
// " -> wOutputOffset: %d\n",
// dn->wDriverOffset,
// dn->wDeviceOffset,
// dn->wOutputOffset);
// printf("QPrintDialogWinPrivate::createDevNames(): %s, %s, %s\n",
// QString::fromUtf16((ushort*)(dn) + dn->wDriverOffset).latin1(),
// QString::fromUtf16((ushort*)(dn) + dn->wDeviceOffset).latin1(),
// QString::fromUtf16((ushort*)(dn) + dn->wOutputOffset).latin1());
return hGlobal;
}, {
int size = sizeof(DEVNAMES)
+ program.length() + 2
+ name.length() + 2
+ port.length() + 2;
HGLOBAL *hGlobal = (HGLOBAL *) GlobalAlloc(GMEM_MOVEABLE, size);
DEVNAMES *dn = (DEVNAMES*) GlobalLock(hGlobal);
dn->wDriverOffset = sizeof(DEVNAMES);
dn->wDeviceOffset = dn->wDriverOffset + program.length() + 1;
dn->wOutputOffset = dn->wDeviceOffset + name.length() + 1;
memcpy((char*)dn + dn->wDriverOffset, program.toLatin1(), program.length() + 2);
memcpy((char*)dn + dn->wDeviceOffset, name.toLatin1(), name.length() + 2);
memcpy((char*)dn + dn->wOutputOffset, port.toLatin1(), port.length() + 2);
dn->wDefault = 0;
GlobalUnlock(hGlobal);
return hGlobal;
} );
}
void QWin32PrintEnginePrivate::readDevnames(HGLOBAL globalDevnames)
{
if (globalDevnames) {
QT_WA( {
DEVNAMES *dn = (DEVNAMES*) GlobalLock(globalDevnames);
name = QString::fromUtf16((ushort*)(dn) + dn->wDeviceOffset);
port = QString::fromUtf16((ushort*)(dn) + dn->wOutputOffset);
program = QString::fromUtf16((ushort*)(dn) + dn->wDriverOffset);
GlobalUnlock(globalDevnames);
}, {
DEVNAMES *dn = (DEVNAMES*) GlobalLock(globalDevnames);
name = QString::fromLatin1((char*)(dn) + dn->wDeviceOffset);
port = QString::fromLatin1((char*)(dn) + dn->wOutputOffset);
program = QString::fromLatin1((char*)(dn) + dn->wDriverOffset);
GlobalUnlock(globalDevnames);
} );
}
}
void QWin32PrintEnginePrivate::readDevmode(HGLOBAL globalDevmode)
{
if (globalDevmode) {
QT_WA( {
DEVMODE *dm = (DEVMODE*) GlobalLock(globalDevmode);
release();
globalDevMode = globalDevmode;
devMode = dm;
hdc = CreateDC(reinterpret_cast<const wchar_t *>(program.utf16()),
reinterpret_cast<const wchar_t *>(name.utf16()), 0, dm);
num_copies = devModeW()->dmCopies;
if (!OpenPrinterW((LPWSTR)name.utf16(), (LPHANDLE)&hPrinter, 0))
qWarning("QPrinter: OpenPrinter() failed after reading DEVMODE.");
}, {
DEVMODEA *dm = (DEVMODEA*) GlobalLock(globalDevmode);
release();
globalDevMode = globalDevmode;
devMode = dm;
hdc = CreateDCA(program.toLatin1(), name.toLatin1(), 0, dm);
num_copies = devModeA()->dmCopies;
if (!OpenPrinterA((LPSTR)name.toLatin1().data(), (LPHANDLE)&hPrinter, 0))
qWarning("QPrinter: OpenPrinter() failed after reading DEVMODE.");
} );
}
if (hdc)
initHDC();
}
static void draw_text_item_win(const QPointF &_pos, const QTextItemInt &ti, HDC hdc,
bool convertToText, const QTransform &xform, const QPointF &topLeft)
{
// Make sure we translate for systems that can't handle world transforms
QPointF pos(QT_WA_INLINE(_pos, _pos + QPointF(xform.dx(), xform.dy())));
QFontEngine *fe = ti.fontEngine;
QPointF baseline_pos = xform.inverted().map(xform.map(pos) - topLeft);
SetTextAlign(hdc, TA_BASELINE);
SetBkMode(hdc, TRANSPARENT);
bool has_kerning = ti.f && ti.f->kerning();
QFontEngineWin *winfe = (fe->type() == QFontEngine::Win) ? static_cast<QFontEngineWin *>(fe) : 0;
HFONT hfont;
bool ttf = false;
bool useTextOutA = false;
if (winfe) {
hfont = winfe->hfont;
ttf = winfe->ttf;
useTextOutA = winfe->useTextOutA;
} else {
hfont = (HFONT)GetStockObject(ANSI_VAR_FONT);
}
HGDIOBJ old_font = SelectObject(hdc, hfont);
unsigned int options = (ttf && !convertToText) ? ETO_GLYPH_INDEX : 0;
wchar_t *convertedGlyphs = (wchar_t *)ti.chars;
QGlyphLayout glyphs = ti.glyphs;
if (!(ti.flags & QTextItem::RightToLeft) && useTextOutA) {
qreal x = pos.x();
qreal y = pos.y();
// hack to get symbol fonts working on Win95. See also QFontEngine constructor
// can only happen if !ttf
for(int i = 0; i < glyphs.numGlyphs; i++) {
QString str(QChar(glyphs.glyphs[i]));
QT_WA({
TextOutW(hdc, qRound(x + glyphs.offsets[i].x.toReal()),
qRound(y + glyphs.offsets[i].y.toReal()),
(LPWSTR)str.utf16(), str.length());
} , {
QByteArray cstr = str.toLocal8Bit();
TextOutA(hdc, qRound(x + glyphs.offsets[i].x.toReal()),
qRound(y + glyphs.offsets[i].y.toReal()),
cstr.data(), cstr.length());
});
x += glyphs.effectiveAdvance(i).toReal();
}
} else {
bool fast = !has_kerning && !(ti.flags & QTextItem::RightToLeft);
for(int i = 0; fast && i < glyphs.numGlyphs; i++) {
if (glyphs.offsets[i].x != 0 || glyphs.offsets[i].y != 0 || glyphs.justifications[i].space_18d6 != 0
|| glyphs.attributes[i].dontPrint) {
fast = false;
break;
}
}
#if !defined(Q_OS_WINCE)
// Scale, rotate and translate here. This is only valid for systems > Windows Me.
// We should never get here on Windows Me or lower if the transformation specifies
// scaling or rotation.
QT_WA({
XFORM win_xform;
win_xform.eM11 = xform.m11();
win_xform.eM12 = xform.m12();
win_xform.eM21 = xform.m21();
win_xform.eM22 = xform.m22();
win_xform.eDx = xform.dx();
win_xform.eDy = xform.dy();
SetGraphicsMode(hdc, GM_ADVANCED);
SetWorldTransform(hdc, &win_xform);
}, {
// nothing
});
#endif
if (fast) {
// fast path
QVarLengthArray<wchar_t> g(glyphs.numGlyphs);
for (int i = 0; i < glyphs.numGlyphs; ++i)
g[i] = glyphs.glyphs[i];
ExtTextOutW(hdc,
qRound(baseline_pos.x() + glyphs.offsets[0].x.toReal()),
qRound(baseline_pos.y() + glyphs.offsets[0].y.toReal()),
options, 0, convertToText ? convertedGlyphs : g.data(), glyphs.numGlyphs, 0);
} else {
QVarLengthArray<QFixedPoint> positions;
QVarLengthArray<glyph_t> _glyphs;
QTransform matrix = QTransform::fromTranslate(baseline_pos.x(), baseline_pos.y());
ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags,
_glyphs, positions);
if (_glyphs.size() == 0) {
SelectObject(hdc, old_font);
return;
}
convertToText = convertToText && glyphs.numGlyphs == _glyphs.size();
bool outputEntireItem = (QSysInfo::WindowsVersion & QSysInfo::WV_NT_based)
&& QSysInfo::WindowsVersion != QSysInfo::WV_NT
&& _glyphs.size() > 0;
if (outputEntireItem) {
options |= ETO_PDY;
QVarLengthArray<INT> glyphDistances(_glyphs.size() * 2);
QVarLengthArray<wchar_t> g(_glyphs.size());
for (int i=0; i<_glyphs.size() - 1; ++i) {
glyphDistances[i * 2] = qRound(positions[i + 1].x) - qRound(positions[i].x);
glyphDistances[i * 2 + 1] = qRound(positions[i + 1].y) - qRound(positions[i].y);
g[i] = _glyphs[i];
}
glyphDistances[(_glyphs.size() - 1) * 2] = 0;
glyphDistances[(_glyphs.size() - 1) * 2 + 1] = 0;
g[_glyphs.size() - 1] = _glyphs[_glyphs.size() - 1];
ExtTextOutW(hdc, qRound(positions[0].x), qRound(positions[0].y), options, 0,
convertToText ? convertedGlyphs : g.data(), _glyphs.size(),
glyphDistances.data());
} else {
int i = 0;
while(i < _glyphs.size()) {
wchar_t g = _glyphs[i];
ExtTextOutW(hdc, qRound(positions[i].x),
qRound(positions[i].y), options, 0,
convertToText ? convertedGlyphs + i : &g, 1, 0);
++i;
}
}
}
#if !defined(Q_OS_WINCE)
QT_WA({
XFORM win_xform;
win_xform.eM11 = win_xform.eM22 = 1.0;
win_xform.eM12 = win_xform.eM21 = win_xform.eDx = win_xform.eDy = 0.0;
SetWorldTransform(hdc, &win_xform);
}, {
// nothing
});
#endif
}
SelectObject(hdc, old_font);
}
void QWin32PrintEnginePrivate::updateCustomPaperSize()
{
QT_WA( {
uint paperSize = devModeW()->dmPaperSize;
if (paperSize > 0 && mapDevmodePaperSize(paperSize) == QPrinter::Custom) {
has_custom_paper_size = true;
DWORD needed = 0;
DWORD returned = 0;
if (!EnumForms(hPrinter, 1, 0, 0, &needed, &returned)) {
BYTE *forms = (BYTE *) malloc(needed);
if (EnumForms(hPrinter, 1, forms, needed, &needed, &returned)) {
if (paperSize <= returned) {
FORM_INFO_1 *formArray = (FORM_INFO_1 *) forms;
int width = formArray[paperSize-1].Size.cx; // 1/1000 of a mm
int height = formArray[paperSize-1].Size.cy; // 1/1000 of a mm
paper_size = QSizeF((width*72/25.4)/1000.0, (height*72/25.4)/1000.0);
} else {
has_custom_paper_size = false;
}
}
free(forms);
}
} else {
has_custom_paper_size = false;
}
}, {
// Not supported under Win98
} );
}
QT_END_NAMESPACE
#endif // QT_NO_PRINTER