Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

qpdf.cpp

Last change on this file was 846, checked in by Dmitry A. Kuminov, 14 years ago
trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.
File size: 59.5 KB

Rev	Line
[2]	1	/****************************************************************************
	2	**
[846]	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
[561]	4	** All rights reserved.
	5	** Contact: Nokia Corporation (qt-info@nokia.com)
[2]	6	**
	7	** This file is part of the QtGui module of the Qt Toolkit.
	8	**
	9	** $QT_BEGIN_LICENSE:LGPL$
	10	** Commercial Usage
	11	** Licensees holding valid Qt Commercial licenses may use this file in
	12	** accordance with the Qt Commercial License Agreement provided with the
	13	** Software or, alternatively, in accordance with the terms contained in
	14	** a written agreement between you and Nokia.
	15	**
	16	** GNU Lesser General Public License Usage
	17	** Alternatively, this file may be used under the terms of the GNU Lesser
	18	** General Public License version 2.1 as published by the Free Software
	19	** Foundation and appearing in the file LICENSE.LGPL included in the
	20	** packaging of this file. Please review the following information to
	21	** ensure the GNU Lesser General Public License version 2.1 requirements
	22	** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
	23	**
[561]	24	** In addition, as a special exception, Nokia gives you certain additional
	25	** rights. These rights are described in the Nokia Qt LGPL Exception
	26	** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
[2]	27	**
	28	** GNU General Public License Usage
	29	** Alternatively, this file may be used under the terms of the GNU
	30	** General Public License version 3.0 as published by the Free Software
	31	** Foundation and appearing in the file LICENSE.GPL included in the
	32	** packaging of this file. Please review the following information to
	33	** ensure the GNU General Public License version 3.0 requirements will be
	34	** met: http://www.gnu.org/copyleft/gpl.html.
	35	**
[561]	36	** If you have questions regarding the use of this file, please contact
	37	** Nokia at qt-info@nokia.com.
[2]	38	** $QT_END_LICENSE$
	39	**
	40	****************************************************************************/
	41	#include "qplatformdefs.h"
	42	#include <qdebug.h>
	43	#include "qpdf_p.h"
	44	#include <qfile.h>
	45	#include <qtemporaryfile.h>
	46	#include <private/qmath_p.h>
	47	#include "private/qcups_p.h"
	48	#include "qprinterinfo.h"
	49	#include <qnumeric.h>
	50
[561]	51	#ifdef Q_OS_UNIX
	52	#include "private/qcore_unix_p.h" // overrides QT_OPEN
	53	#endif
	54
[2]	55	QT_BEGIN_NAMESPACE
	56
[769]	57	Q_GUI_EXPORT extern int qt_defaultDpi();
[2]	58
	59	#ifndef QT_NO_PRINTER
	60
	61	extern QSizeF qt_paperSizeToQSizeF(QPrinter::PaperSize size);
	62
	63	/* also adds a space at the end of the number */
	64	const char qt_real_to_string(qreal val, char buf) {
	65	const char *ret = buf;
	66
	67	if (qIsNaN(val)) {
	68	*(buf++) = '0';
	69	*(buf++) = ' ';
	70	*buf = 0;
	71	return ret;
	72	}
	73
	74	if (val < 0) {
	75	*(buf++) = '-';
	76	val = -val;
	77	}
	78	unsigned int ival = (unsigned int) val;
	79	qreal frac = val - (qreal)ival;
	80
[561]	81	int ifrac = (int)(frac * 1000000000);
	82	if (ifrac == 1000000000) {
[2]	83	++ival;
	84	ifrac = 0;
	85	}
	86	char output[256];
	87	int i = 0;
	88	while (ival) {
	89	output[i] = '0' + (ival % 10);
	90	++i;
	91	ival /= 10;
	92	}
[561]	93	int fact = 100000000;
[2]	94	if (i == 0) {
	95	*(buf++) = '0';
	96	} else {
	97	while (i) {
	98	*(buf++) = output[--i];
	99	fact /= 10;
	100	ifrac /= 10;
	101	}
	102	}
	103
	104	if (ifrac) {
	105	*(buf++) = '.';
	106	while (fact) {
	107	*(buf++) = '0' + ((ifrac/fact) % 10);
	108	fact /= 10;
	109	}
	110	}
	111	*(buf++) = ' ';
	112	*buf = 0;
	113	return ret;
	114	}
	115
	116	const char qt_int_to_string(int val, char buf) {
	117	const char *ret = buf;
	118	if (val < 0) {
	119	*(buf++) = '-';
	120	val = -val;
	121	}
	122	char output[256];
	123	int i = 0;
	124	while (val) {
	125	output[i] = '0' + (val % 10);
	126	++i;
	127	val /= 10;
	128	}
	129	if (i == 0) {
	130	*(buf++) = '0';
	131	} else {
	132	while (i)
	133	*(buf++) = output[--i];
	134	}
	135	*(buf++) = ' ';
	136	*buf = 0;
	137	return ret;
	138	}
	139
	140
	141	namespace QPdf {
	142	ByteStream::ByteStream(QByteArray *byteArray, bool fileBacking)
	143	: dev(new QBuffer(byteArray)),
	144	fileBackingEnabled(fileBacking),
	145	fileBackingActive(false),
	146	handleDirty(false)
	147	{
[561]	148	dev->open(QIODevice::ReadWrite \| QIODevice::Append);
[2]	149	}
	150
	151	ByteStream::ByteStream(bool fileBacking)
	152	: dev(new QBuffer(&ba)),
	153	fileBackingEnabled(fileBacking),
	154	fileBackingActive(false),
	155	handleDirty(false)
	156	{
	157	dev->open(QIODevice::ReadWrite);
	158	}
	159
	160	ByteStream::~ByteStream()
	161	{
	162	delete dev;
	163	}
	164
	165	ByteStream &ByteStream::operator <<(char chr)
	166	{
	167	if (handleDirty) prepareBuffer();
	168	dev->write(&chr, 1);
	169	return *this;
	170	}
	171
	172	ByteStream &ByteStream::operator <<(const char *str)
	173	{
	174	if (handleDirty) prepareBuffer();
	175	dev->write(str, strlen(str));
	176	return *this;
	177	}
	178
	179	ByteStream &ByteStream::operator <<(const QByteArray &str)
	180	{
	181	if (handleDirty) prepareBuffer();
	182	dev->write(str);
	183	return *this;
	184	}
	185
	186	ByteStream &ByteStream::operator <<(const ByteStream &src)
	187	{
	188	Q_ASSERT(!src.dev->isSequential());
	189	if (handleDirty) prepareBuffer();
	190	// We do play nice here, even though it looks ugly.
	191	// We save the position and restore it afterwards.
	192	ByteStream &s = const_cast<ByteStream&>(src);
	193	qint64 pos = s.dev->pos();
	194	s.dev->reset();
	195	while (!s.dev->atEnd()) {
	196	QByteArray buf = s.dev->read(chunkSize());
	197	dev->write(buf);
	198	}
	199	s.dev->seek(pos);
	200	return *this;
	201	}
	202
	203	ByteStream &ByteStream::operator <<(qreal val) {
	204	char buf[256];
	205	qt_real_to_string(val, buf);
	206	*this << buf;
	207	return *this;
	208	}
	209
	210	ByteStream &ByteStream::operator <<(int val) {
	211	char buf[256];
	212	qt_int_to_string(val, buf);
	213	*this << buf;
	214	return *this;
	215	}
	216
	217	ByteStream &ByteStream::operator <<(const QPointF &p) {
	218	char buf[256];
	219	qt_real_to_string(p.x(), buf);
	220	*this << buf;
	221	qt_real_to_string(p.y(), buf);
	222	*this << buf;
	223	return *this;
	224	}
	225
	226	QIODevice *ByteStream::stream()
	227	{
	228	dev->reset();
	229	handleDirty = true;
	230	return dev;
	231	}
	232
	233	void ByteStream::clear()
	234	{
	235	dev->open(QIODevice::ReadWrite \| QIODevice::Truncate);
	236	}
	237
	238	void ByteStream::constructor_helper(QByteArray *ba)
	239	{
	240	delete dev;
	241	dev = new QBuffer(ba);
	242	dev->open(QIODevice::ReadWrite);
	243	}
	244
	245	void ByteStream::prepareBuffer()
	246	{
	247	Q_ASSERT(!dev->isSequential());
	248	qint64 size = dev->size();
	249	if (fileBackingEnabled && !fileBackingActive
	250	&& size > maxMemorySize()) {
	251	// Switch to file backing.
	252	QTemporaryFile *newFile = new QTemporaryFile;
	253	newFile->open();
	254	dev->reset();
	255	while (!dev->atEnd()) {
	256	QByteArray buf = dev->read(chunkSize());
	257	newFile->write(buf);
	258	}
	259	delete dev;
	260	dev = newFile;
	261	ba.clear();
	262	fileBackingActive = true;
	263	}
	264	if (dev->pos() != size) {
	265	dev->seek(size);
	266	handleDirty = false;
	267	}
	268	}
	269	}
	270
	271	#define QT_PATH_ELEMENT(elm)
	272
	273	QByteArray QPdf::generatePath(const QPainterPath &path, const QTransform &matrix, PathFlags flags)
	274	{
	275	QByteArray result;
	276	if (!path.elementCount())
	277	return result;
	278
	279	ByteStream s(&result);
	280
	281	int start = -1;
	282	for (int i = 0; i < path.elementCount(); ++i) {
	283	const QPainterPath::Element &elm = path.elementAt(i);
	284	switch (elm.type) {
	285	case QPainterPath::MoveToElement:
	286	if (start >= 0
	287	&& path.elementAt(start).x == path.elementAt(i-1).x
	288	&& path.elementAt(start).y == path.elementAt(i-1).y)
	289	s << "h\n";
	290	s << matrix.map(QPointF(elm.x, elm.y)) << "m\n";
	291	start = i;
	292	break;
	293	case QPainterPath::LineToElement:
	294	s << matrix.map(QPointF(elm.x, elm.y)) << "l\n";
	295	break;
	296	case QPainterPath::CurveToElement:
	297	Q_ASSERT(path.elementAt(i+1).type == QPainterPath::CurveToDataElement);
	298	Q_ASSERT(path.elementAt(i+2).type == QPainterPath::CurveToDataElement);
	299	s << matrix.map(QPointF(elm.x, elm.y))
	300	<< matrix.map(QPointF(path.elementAt(i+1).x, path.elementAt(i+1).y))
	301	<< matrix.map(QPointF(path.elementAt(i+2).x, path.elementAt(i+2).y))
	302	<< "c\n";
	303	i += 2;
	304	break;
	305	default:
	306	qFatal("QPdf::generatePath(), unhandled type: %d", elm.type);
	307	}
	308	}
	309	if (start >= 0
	310	&& path.elementAt(start).x == path.elementAt(path.elementCount()-1).x
	311	&& path.elementAt(start).y == path.elementAt(path.elementCount()-1).y)
	312	s << "h\n";
	313
	314	Qt::FillRule fillRule = path.fillRule();
	315
[561]	316	const char *op = "";
[2]	317	switch (flags) {
	318	case ClipPath:
	319	op = (fillRule == Qt::WindingFill) ? "W n\n" : "W* n\n";
	320	break;
	321	case FillPath:
	322	op = (fillRule == Qt::WindingFill) ? "f\n" : "f*\n";
	323	break;
	324	case StrokePath:
	325	op = "S\n";
	326	break;
	327	case FillAndStrokePath:
	328	op = (fillRule == Qt::WindingFill) ? "B\n" : "B*\n";
	329	break;
	330	}
	331	s << op;
	332	return result;
	333	}
	334
	335	QByteArray QPdf::generateMatrix(const QTransform &matrix)
	336	{
	337	QByteArray result;
	338	ByteStream s(&result);
	339	s << matrix.m11()
	340	<< matrix.m12()
	341	<< matrix.m21()
	342	<< matrix.m22()
	343	<< matrix.dx()
	344	<< matrix.dy()
	345	<< "cm\n";
	346	return result;
	347	}
	348
	349	QByteArray QPdf::generateDashes(const QPen &pen)
	350	{
	351	QByteArray result;
	352	ByteStream s(&result);
[561]	353	s << '[';
[2]	354
	355	QVector<qreal> dasharray = pen.dashPattern();
	356	qreal w = pen.widthF();
	357	if (w < 0.001)
	358	w = 1;
	359	for (int i = 0; i < dasharray.size(); ++i) {
	360	qreal dw = dasharray.at(i)*w;
	361	if (dw < 0.0001) dw = 0.0001;
	362	s << dw;
	363	}
[561]	364	s << ']';
[2]	365	//qDebug() << "dasharray: pen has" << dasharray;
	366	//qDebug() << " => " << result;
	367	return result;
	368	}
	369
	370
	371
	372	static const char* pattern_for_brush[] = {
	373	0, // NoBrush
	374	0, // SolidPattern
	375	"0 J\n"
	376	"6 w\n"
	377	"[] 0 d\n"
	378	"4 0 m\n"
	379	"4 8 l\n"
	380	"0 4 m\n"
	381	"8 4 l\n"
	382	"S\n", // Dense1Pattern
	383
	384	"0 J\n"
	385	"2 w\n"
	386	"[6 2] 1 d\n"
	387	"0 0 m\n"
	388	"0 8 l\n"
	389	"8 0 m\n"
	390	"8 8 l\n"
	391	"S\n"
	392	"[] 0 d\n"
	393	"2 0 m\n"
	394	"2 8 l\n"
	395	"6 0 m\n"
	396	"6 8 l\n"
	397	"S\n"
	398	"[6 2] -3 d\n"
	399	"4 0 m\n"
	400	"4 8 l\n"
	401	"S\n", // Dense2Pattern
	402
	403	"0 J\n"
	404	"2 w\n"
	405	"[6 2] 1 d\n"
	406	"0 0 m\n"
	407	"0 8 l\n"
	408	"8 0 m\n"
	409	"8 8 l\n"
	410	"S\n"
	411	"[2 2] -1 d\n"
	412	"2 0 m\n"
	413	"2 8 l\n"
	414	"6 0 m\n"
	415	"6 8 l\n"
	416	"S\n"
	417	"[6 2] -3 d\n"
	418	"4 0 m\n"
	419	"4 8 l\n"
	420	"S\n", // Dense3Pattern
	421
	422	"0 J\n"
	423	"2 w\n"
	424	"[2 2] 1 d\n"
	425	"0 0 m\n"
	426	"0 8 l\n"
	427	"8 0 m\n"
	428	"8 8 l\n"
	429	"S\n"
	430	"[2 2] -1 d\n"
	431	"2 0 m\n"
	432	"2 8 l\n"
	433	"6 0 m\n"
	434	"6 8 l\n"
	435	"S\n"
	436	"[2 2] 1 d\n"
	437	"4 0 m\n"
	438	"4 8 l\n"
	439	"S\n", // Dense4Pattern
	440
	441	"0 J\n"
	442	"2 w\n"
	443	"[2 6] -1 d\n"
	444	"0 0 m\n"
	445	"0 8 l\n"
	446	"8 0 m\n"
	447	"8 8 l\n"
	448	"S\n"
	449	"[2 2] 1 d\n"
	450	"2 0 m\n"
	451	"2 8 l\n"
	452	"6 0 m\n"
	453	"6 8 l\n"
	454	"S\n"
	455	"[2 6] 3 d\n"
	456	"4 0 m\n"
	457	"4 8 l\n"
	458	"S\n", // Dense5Pattern
	459
	460	"0 J\n"
	461	"2 w\n"
	462	"[2 6] -1 d\n"
	463	"0 0 m\n"
	464	"0 8 l\n"
	465	"8 0 m\n"
	466	"8 8 l\n"
	467	"S\n"
	468	"[2 6] 3 d\n"
	469	"4 0 m\n"
	470	"4 8 l\n"
	471	"S\n", // Dense6Pattern
	472
	473	"0 J\n"
	474	"2 w\n"
	475	"[2 6] -1 d\n"
	476	"0 0 m\n"
	477	"0 8 l\n"
	478	"8 0 m\n"
	479	"8 8 l\n"
	480	"S\n", // Dense7Pattern
	481
	482	"1 w\n"
	483	"0 4 m\n"
	484	"8 4 l\n"
	485	"S\n", // HorPattern
	486
	487	"1 w\n"
	488	"4 0 m\n"
	489	"4 8 l\n"
	490	"S\n", // VerPattern
	491
	492	"1 w\n"
	493	"4 0 m\n"
	494	"4 8 l\n"
	495	"0 4 m\n"
	496	"8 4 l\n"
	497	"S\n", // CrossPattern
	498
	499	"1 w\n"
	500	"-1 5 m\n"
	501	"5 -1 l\n"
	502	"3 9 m\n"
	503	"9 3 l\n"
	504	"S\n", // BDiagPattern
	505
	506	"1 w\n"
	507	"-1 3 m\n"
	508	"5 9 l\n"
	509	"3 -1 m\n"
	510	"9 5 l\n"
	511	"S\n", // FDiagPattern
	512
	513	"1 w\n"
	514	"-1 3 m\n"
	515	"5 9 l\n"
	516	"3 -1 m\n"
	517	"9 5 l\n"
	518	"-1 5 m\n"
	519	"5 -1 l\n"
	520	"3 9 m\n"
	521	"9 3 l\n"
	522	"S\n", // DiagCrossPattern
	523	};
	524
	525	QByteArray QPdf::patternForBrush(const QBrush &b)
	526	{
	527	int style = b.style();
	528	if (style > Qt::DiagCrossPattern)
	529	return QByteArray();
	530	return pattern_for_brush[style];
	531	}
	532
	533	#ifdef USE_NATIVE_GRADIENTS
	534	static void writeTriangleLine(uchar *&data, int xpos, int ypos, int xoff, int yoff, uint rgb, uchar flag, bool alpha)
	535	{
	536	data[0] = flag;
	537	data[1] = (uchar)(xpos >> 16);
	538	data[2] = (uchar)(xpos >> 8);
	539	data[3] = (uchar)(xpos >> 0);
	540	data[4] = (uchar)(ypos >> 16);
	541	data[5] = (uchar)(ypos >> 8);
	542	data[6] = (uchar)(ypos >> 0);
	543	data += 7;
	544	if (alpha) {
	545	*data++ = (uchar)qAlpha(rgb);
	546	} else {
	547	*data++ = (uchar)qRed(rgb);
	548	*data++ = (uchar)qGreen(rgb);
	549	*data++ = (uchar)qBlue(rgb);
	550	}
	551	xpos += xoff;
	552	ypos += yoff;
	553	data[0] = flag;
	554	data[1] = (uchar)(xpos >> 16);
	555	data[2] = (uchar)(xpos >> 8);
	556	data[3] = (uchar)(xpos >> 0);
	557	data[4] = (uchar)(ypos >> 16);
	558	data[5] = (uchar)(ypos >> 8);
	559	data[6] = (uchar)(ypos >> 0);
	560	data += 7;
	561	if (alpha) {
	562	*data++ = (uchar)qAlpha(rgb);
	563	} else {
	564	*data++ = (uchar)qRed(rgb);
	565	*data++ = (uchar)qGreen(rgb);
	566	*data++ = (uchar)qBlue(rgb);
	567	}
	568	}
	569
	570
	571	QByteArray QPdf::generateLinearGradientShader(const QLinearGradient gradient, const QPointF page_rect, bool alpha)
	572	{
	573	// generate list of triangles with colors
	574	QPointF start = gradient->start();
	575	QPointF stop = gradient->finalStop();
	576	QGradientStops stops = gradient->stops();
	577	QPointF offset = stop - start;
	578	QGradient::Spread spread = gradient->spread();
	579
	580	if (gradient->spread() == QGradient::ReflectSpread) {
	581	offset *= 2;
	582	for (int i = stops.size() - 2; i >= 0; --i) {
	583	QGradientStop stop = stops.at(i);
	584	stop.first = 2. - stop.first;
	585	stops.append(stop);
	586	}
	587	for (int i = 0 ; i < stops.size(); ++i)
	588	stops[i].first /= 2.;
	589	}
	590
	591	QPointF orthogonal(offset.y(), -offset.x());
	592	qreal length = offset.x()offset.x() + offset.y()offset.y();
	593
	594	// find the max and min values in offset and orth direction that are needed to cover
	595	// the whole page
	596	int off_min = INT_MAX;
	597	int off_max = INT_MIN;
	598	qreal ort_min = INT_MAX;
	599	qreal ort_max = INT_MIN;
	600	for (int i = 0; i < 4; ++i) {
	601	qreal off = ((page_rect[i].x() - start.x()) * offset.x() + (page_rect[i].y() - start.y()) * offset.y())/length;
	602	qreal ort = ((page_rect[i].x() - start.x()) * orthogonal.x() + (page_rect[i].y() - start.y()) * orthogonal.y())/length;
	603	off_min = qMin(off_min, qFloor(off));
	604	off_max = qMax(off_max, qCeil(off));
	605	ort_min = qMin(ort_min, ort);
	606	ort_max = qMax(ort_max, ort);
	607	}
	608	ort_min -= 1;
	609	ort_max += 1;
	610
	611	start += off_min * offset + ort_min * orthogonal;
	612	orthogonal *= (ort_max - ort_min);
	613	int num = off_max - off_min;
	614
	615	QPointF gradient_rect[4] = { start,
	616	start + orthogonal,
	617	start + num*offset,
	618	start + num*offset + orthogonal };
	619	qreal xmin = gradient_rect[0].x();
	620	qreal xmax = gradient_rect[0].x();
	621	qreal ymin = gradient_rect[0].y();
	622	qreal ymax = gradient_rect[0].y();
	623	for (int i = 1; i < 4; ++i) {
	624	xmin = qMin(xmin, gradient_rect[i].x());
	625	xmax = qMax(xmax, gradient_rect[i].x());
	626	ymin = qMin(ymin, gradient_rect[i].y());
	627	ymax = qMax(ymax, gradient_rect[i].y());
	628	}
	629	xmin -= 1000;
	630	xmax += 1000;
	631	ymin -= 1000;
	632	ymax += 1000;
	633	start -= QPointF(xmin, ymin);
	634	qreal factor_x = qreal(1<<24)/(xmax - xmin);
	635	qreal factor_y = qreal(1<<24)/(ymax - ymin);
	636	int xoff = (int)(orthogonal.x()*factor_x);
	637	int yoff = (int)(orthogonal.y()*factor_y);
	638
	639	QByteArray triangles;
	640	triangles.resize(spread == QGradient::PadSpread ? 20(stops.size()+2) : 20num*stops.size());
	641	uchar data = (uchar ) triangles.data();
	642	if (spread == QGradient::PadSpread) {
	643	if (off_min > 0 \|\| off_max < 1) {
	644	// linear gradient outside of page
	645	const QGradientStop &current_stop = off_min > 0 ? stops.at(stops.size()-1) : stops.at(0);
	646	uint rgb = current_stop.second.rgba();
	647	int xpos = (int)(start.x()*factor_x);
	648	int ypos = (int)(start.y()*factor_y);
	649	writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, 0, alpha);
	650	start += num*offset;
	651	xpos = (int)(start.x()*factor_x);
	652	ypos = (int)(start.y()*factor_y);
	653	writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, 1, alpha);
	654	} else {
	655	int flag = 0;
	656	if (off_min < 0) {
	657	uint rgb = stops.at(0).second.rgba();
	658	int xpos = (int)(start.x()*factor_x);
	659	int ypos = (int)(start.y()*factor_y);
	660	writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, flag, alpha);
	661	start -= off_min*offset;
	662	flag = 1;
	663	}
	664	for (int s = 0; s < stops.size(); ++s) {
	665	const QGradientStop &current_stop = stops.at(s);
	666	uint rgb = current_stop.second.rgba();
	667	int xpos = (int)(start.x()*factor_x);
	668	int ypos = (int)(start.y()*factor_y);
	669	writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, flag, alpha);
	670	if (s < stops.size()-1)
	671	start += offset*(stops.at(s+1).first - stops.at(s).first);
	672	flag = 1;
	673	}
	674	if (off_max > 1) {
	675	start += (off_max - 1)*offset;
	676	uint rgb = stops.at(stops.size()-1).second.rgba();
	677	int xpos = (int)(start.x()*factor_x);
	678	int ypos = (int)(start.y()*factor_y);
	679	writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, flag, alpha);
	680	}
	681	}
	682	} else {
	683	for (int i = 0; i < num; ++i) {
	684	uchar flag = 0;
	685	for (int s = 0; s < stops.size(); ++s) {
	686	uint rgb = stops.at(s).second.rgba();
	687	int xpos = (int)(start.x()*factor_x);
	688	int ypos = (int)(start.y()*factor_y);
	689	writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, flag, alpha);
	690	if (s < stops.size()-1)
	691	start += offset*(stops.at(s+1).first - stops.at(s).first);
	692	flag = 1;
	693	}
	694	}
	695	}
	696	triangles.resize((char *)data - triangles.constData());
	697
	698	QByteArray shader;
	699	QPdf::ByteStream s(&shader);
	700	s << "<<\n"
	701	"/ShadingType 4\n"
	702	"/ColorSpace " << (alpha ? "/DeviceGray\n" : "/DeviceRGB\n") <<
	703	"/AntiAlias true\n"
	704	"/BitsPerCoordinate 24\n"
	705	"/BitsPerComponent 8\n"
	706	"/BitsPerFlag 8\n"
	707	"/Decode [" << xmin << xmax << ymin << ymax << (alpha ? "0 1]\n" : "0 1 0 1 0 1]\n") <<
	708	"/AntiAlias true\n"
	709	"/Length " << triangles.length() << "\n"
	710	">>\n"
	711	"stream\n" << triangles << "endstream\n"
	712	"endobj\n";
	713	return shader;
	714	}
	715	#endif
	716
	717	static void moveToHook(qfixed x, qfixed y, void *data)
	718	{
	719	QPdf::Stroker t = (QPdf::Stroker )data;
	720	if (!t->first)
	721	*t->stream << "h\n";
	722	if (!t->cosmeticPen)
	723	t->matrix.map(x, y, &x, &y);
	724	*t->stream << x << y << "m\n";
	725	t->first = false;
	726	}
	727
	728	static void lineToHook(qfixed x, qfixed y, void *data)
	729	{
	730	QPdf::Stroker t = (QPdf::Stroker )data;
	731	if (!t->cosmeticPen)
	732	t->matrix.map(x, y, &x, &y);
	733	*t->stream << x << y << "l\n";
	734	}
	735
	736	static void cubicToHook(qfixed c1x, qfixed c1y,
	737	qfixed c2x, qfixed c2y,
	738	qfixed ex, qfixed ey,
	739	void *data)
	740	{
	741	QPdf::Stroker t = (QPdf::Stroker )data;
	742	if (!t->cosmeticPen) {
	743	t->matrix.map(c1x, c1y, &c1x, &c1y);
	744	t->matrix.map(c2x, c2y, &c2x, &c2y);
	745	t->matrix.map(ex, ey, &ex, &ey);
	746	}
	747	*t->stream << c1x << c1y
	748	<< c2x << c2y
	749	<< ex << ey
	750	<< "c\n";
	751	}
	752
	753	QPdf::Stroker::Stroker()
	754	: stream(0),
	755	first(true),
	756	dashStroker(&basicStroker)
	757	{
	758	stroker = &basicStroker;
	759	basicStroker.setMoveToHook(moveToHook);
	760	basicStroker.setLineToHook(lineToHook);
	761	basicStroker.setCubicToHook(cubicToHook);
	762	cosmeticPen = true;
	763	basicStroker.setStrokeWidth(.1);
	764	}
	765
	766	void QPdf::Stroker::setPen(const QPen &pen)
	767	{
	768	if (pen.style() == Qt::NoPen) {
	769	stroker = 0;
	770	return;
	771	}
	772	qreal w = pen.widthF();
	773	bool zeroWidth = w < 0.0001;
	774	cosmeticPen = pen.isCosmetic();
	775	if (zeroWidth)
	776	w = .1;
	777
	778	basicStroker.setStrokeWidth(w);
	779	basicStroker.setCapStyle(pen.capStyle());
	780	basicStroker.setJoinStyle(pen.joinStyle());
	781	basicStroker.setMiterLimit(pen.miterLimit());
	782
	783	QVector<qreal> dashpattern = pen.dashPattern();
	784	if (zeroWidth) {
	785	for (int i = 0; i < dashpattern.size(); ++i)
	786	dashpattern[i] *= 10.;
	787	}
	788	if (!dashpattern.isEmpty()) {
	789	dashStroker.setDashPattern(dashpattern);
	790	dashStroker.setDashOffset(pen.dashOffset());
	791	stroker = &dashStroker;
	792	} else {
	793	stroker = &basicStroker;
	794	}
	795	}
	796
	797	void QPdf::Stroker::strokePath(const QPainterPath &path)
	798	{
	799	if (!stroker)
	800	return;
	801	first = true;
	802
	803	stroker->strokePath(path, this, cosmeticPen ? matrix : QTransform());
	804	*stream << "h f\n";
	805	}
	806
	807	QByteArray QPdf::ascii85Encode(const QByteArray &input)
	808	{
	809	int isize = input.size()/4*4;
	810	QByteArray output;
	811	output.resize(input.size()*5/4+7);
	812	char *out = output.data();
	813	const uchar in = (const uchar )input.constData();
	814	for (int i = 0; i < isize; i += 4) {
	815	uint val = (((uint)in[i])<<24) + (((uint)in[i+1])<<16) + (((uint)in[i+2])<<8) + (uint)in[i+3];
	816	if (val == 0) {
	817	*out = 'z';
	818	++out;
	819	} else {
	820	char base[5];
	821	base[4] = val % 85;
	822	val /= 85;
	823	base[3] = val % 85;
	824	val /= 85;
	825	base[2] = val % 85;
	826	val /= 85;
	827	base[1] = val % 85;
	828	val /= 85;
	829	base[0] = val % 85;
	830	*(out++) = base[0] + '!';
	831	*(out++) = base[1] + '!';
	832	*(out++) = base[2] + '!';
	833	*(out++) = base[3] + '!';
	834	*(out++) = base[4] + '!';
	835	}
	836	}
	837	//write the last few bytes
	838	int remaining = input.size() - isize;
	839	if (remaining) {
	840	uint val = 0;
	841	for (int i = isize; i < input.size(); ++i)
	842	val = (val << 8) + in[i];
	843	val <<= 8*(4-remaining);
	844	char base[5];
	845	base[4] = val % 85;
	846	val /= 85;
	847	base[3] = val % 85;
	848	val /= 85;
	849	base[2] = val % 85;
	850	val /= 85;
	851	base[1] = val % 85;
	852	val /= 85;
	853	base[0] = val % 85;
	854	for (int i = 0; i < remaining+1; ++i)
	855	*(out++) = base[i] + '!';
	856	}
	857	*(out++) = '~';
	858	*(out++) = '>';
	859	output.resize(out-output.data());
	860	return output;
	861	}
	862
	863	const char QPdf::toHex(ushort u, char buffer)
	864	{
	865	int i = 3;
	866	while (i >= 0) {
	867	ushort hex = (u & 0x000f);
	868	if (hex < 0x0a)
	869	buffer[i] = '0'+hex;
	870	else
	871	buffer[i] = 'A'+(hex-0x0a);
	872	u = u >> 4;
	873	i--;
	874	}
	875	buffer[4] = '\0';
	876	return buffer;
	877	}
	878
	879	const char QPdf::toHex(uchar u, char buffer)
	880	{
	881	int i = 1;
	882	while (i >= 0) {
	883	ushort hex = (u & 0x000f);
	884	if (hex < 0x0a)
	885	buffer[i] = '0'+hex;
	886	else
	887	buffer[i] = 'A'+(hex-0x0a);
	888	u = u >> 4;
	889	i--;
	890	}
	891	buffer[2] = '\0';
	892	return buffer;
	893	}
	894
	895	#define Q_MM(n) int((n * 720 + 127) / 254)
	896	#define Q_IN(n) int(n * 72)
	897
	898	static const char * const psToStr[QPrinter::NPaperSize+1] =
	899	{
	900	"A4", "B5", "Letter", "Legal", "Executive",
	901	"A0", "A1", "A2", "A3", "A5", "A6", "A7", "A8", "A9", "B0", "B1",
	902	"B10", "B2", "B3", "B4", "B6", "B7", "B8", "B9", "C5E", "Comm10E",
	903	"DLE", "Folio", "Ledger", "Tabloid", 0
	904	};
	905
	906	QPdf::PaperSize QPdf::paperSize(QPrinter::PaperSize paperSize)
	907	{
	908	QSizeF s = qt_paperSizeToQSizeF(paperSize);
	909	PaperSize p = { Q_MM(s.width()), Q_MM(s.height()) };
	910	return p;
	911	}
	912
	913	const char *QPdf::paperSizeToString(QPrinter::PaperSize paperSize)
	914	{
	915	return psToStr[paperSize];
	916	}
	917
	918
	919	// -------------------------- base engine, shared code between PS and PDF -----------------------
	920
	921	QPdfBaseEngine::QPdfBaseEngine(QPdfBaseEnginePrivate &dd, PaintEngineFeatures f)
	922	: QAlphaPaintEngine(dd, f)
	923	{
	924	Q_D(QPdfBaseEngine);
[573]	925	#if !defined(QT_NO_CUPS) && (!defined(QT_NO_LIBRARY) \|\| defined(Q_WS_PM))
[2]	926	if (QCUPSSupport::isAvailable()) {
	927	QCUPSSupport cups;
	928	const cups_dest_t* printers = cups.availablePrinters();
	929	int prnCount = cups.availablePrintersCount();
	930
	931	for (int i = 0; i < prnCount; ++i) {
	932	if (printers[i].is_default) {
	933	d->printerName = QString::fromLocal8Bit(printers[i].name);
	934	break;
	935	}
	936	}
	937
	938	} else
	939	#endif
	940	{
	941	d->printerName = QString::fromLocal8Bit(qgetenv("PRINTER"));
	942	if (d->printerName.isEmpty())
	943	d->printerName = QString::fromLocal8Bit(qgetenv("LPDEST"));
	944	if (d->printerName.isEmpty())
	945	d->printerName = QString::fromLocal8Bit(qgetenv("NPRINTER"));
	946	if (d->printerName.isEmpty())
	947	d->printerName = QString::fromLocal8Bit(qgetenv("NGPRINTER"));
	948	}
	949	}
	950
	951	void QPdfBaseEngine::drawPoints (const QPointF *points, int pointCount)
	952	{
[561]	953	if (!points)
[2]	954	return;
	955
[769]	956	Q_D(QPdfBaseEngine);
[2]	957	QPainterPath p;
	958	for (int i=0; i!=pointCount;++i) {
	959	p.moveTo(points[i]);
	960	p.lineTo(points[i] + QPointF(0, 0.001));
	961	}
[769]	962
	963	bool hadBrush = d->hasBrush;
	964	d->hasBrush = false;
[2]	965	drawPath(p);
[769]	966	d->hasBrush = hadBrush;
[2]	967	}
	968
	969	void QPdfBaseEngine::drawLines (const QLineF *lines, int lineCount)
	970	{
	971	if (!lines)
	972	return;
	973
[769]	974	Q_D(QPdfBaseEngine);
[2]	975	QPainterPath p;
	976	for (int i=0; i!=lineCount;++i) {
	977	p.moveTo(lines[i].p1());
	978	p.lineTo(lines[i].p2());
	979	}
[769]	980	bool hadBrush = d->hasBrush;
	981	d->hasBrush = false;
[2]	982	drawPath(p);
[769]	983	d->hasBrush = hadBrush;
[2]	984	}
	985
	986	void QPdfBaseEngine::drawRects (const QRectF *rects, int rectCount)
	987	{
	988	if (!rects)
	989	return;
	990
	991	Q_D(QPdfBaseEngine);
[561]	992	if (d->useAlphaEngine) {
	993	QAlphaPaintEngine::drawRects(rects, rectCount);
	994	if (!continueCall())
	995	return;
	996	}
	997
[2]	998	if (d->clipEnabled && d->allClipped)
	999	return;
	1000	if (!d->hasPen && !d->hasBrush)
	1001	return;
	1002
	1003	QBrush penBrush = d->pen.brush();
	1004	if (d->simplePen \|\| !d->hasPen) {
	1005	// draw strokes natively in this case for better output
	1006	if(!d->simplePen && !d->stroker.matrix.isIdentity())
	1007	*d->currentPage << "q\n" << QPdf::generateMatrix(d->stroker.matrix);
	1008	for (int i = 0; i < rectCount; ++i)
	1009	*d->currentPage << rects[i].x() << rects[i].y() << rects[i].width() << rects[i].height() << "re\n";
	1010	*d->currentPage << (d->hasPen ? (d->hasBrush ? "B\n" : "S\n") : "f\n");
	1011	if(!d->simplePen && !d->stroker.matrix.isIdentity())
	1012	*d->currentPage << "Q\n";
	1013	} else {
	1014	QPainterPath p;
	1015	for (int i=0; i!=rectCount; ++i)
	1016	p.addRect(rects[i]);
	1017	drawPath(p);
	1018	}
	1019	}
	1020
	1021	void QPdfBaseEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
	1022	{
	1023	Q_D(QPdfBaseEngine);
	1024
	1025	if (d->useAlphaEngine) {
	1026	QAlphaPaintEngine::drawPolygon(points, pointCount, mode);
	1027	if (!continueCall())
	1028	return;
	1029	}
	1030
	1031	if (!points \|\| !pointCount)
	1032	return;
	1033
	1034	bool hb = d->hasBrush;
	1035	QPainterPath p;
	1036
	1037	switch(mode) {
	1038	case OddEvenMode:
	1039	p.setFillRule(Qt::OddEvenFill);
	1040	break;
	1041	case ConvexMode:
	1042	case WindingMode:
	1043	p.setFillRule(Qt::WindingFill);
	1044	break;
	1045	case PolylineMode:
	1046	d->hasBrush = false;
	1047	break;
	1048	default:
	1049	break;
	1050	}
	1051
	1052	p.moveTo(points[0]);
	1053	for (int i = 1; i < pointCount; ++i)
	1054	p.lineTo(points[i]);
	1055
	1056	if (mode != PolylineMode)
	1057	p.closeSubpath();
	1058	drawPath(p);
	1059
	1060	d->hasBrush = hb;
	1061	}
	1062
	1063	void QPdfBaseEngine::drawPath (const QPainterPath &p)
	1064	{
	1065	Q_D(QPdfBaseEngine);
	1066
	1067	if (d->useAlphaEngine) {
	1068	QAlphaPaintEngine::drawPath(p);
	1069	if (!continueCall())
	1070	return;
	1071	}
	1072
	1073	if (d->clipEnabled && d->allClipped)
	1074	return;
	1075	if (!d->hasPen && !d->hasBrush)
	1076	return;
	1077
	1078	if (d->simplePen) {
	1079	// draw strokes natively in this case for better output
	1080	*d->currentPage << QPdf::generatePath(p, QTransform(), d->hasBrush ? QPdf::FillAndStrokePath : QPdf::StrokePath);
	1081	} else {
	1082	if (d->hasBrush)
	1083	*d->currentPage << QPdf::generatePath(p, d->stroker.matrix, QPdf::FillPath);
	1084	if (d->hasPen) {
	1085	*d->currentPage << "q\n";
	1086	QBrush b = d->brush;
	1087	d->brush = d->pen.brush();
	1088	setBrush();
	1089	d->stroker.strokePath(p);
	1090	*d->currentPage << "Q\n";
	1091	d->brush = b;
	1092	}
	1093	}
	1094	}
	1095
	1096	void QPdfBaseEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
	1097	{
	1098	Q_D(QPdfBaseEngine);
	1099
	1100	if (d->useAlphaEngine) {
	1101	QAlphaPaintEngine::drawTextItem(p, textItem);
	1102	if (!continueCall())
	1103	return;
	1104	}
	1105
	1106	if (!d->hasPen \|\| (d->clipEnabled && d->allClipped))
	1107	return;
	1108
	1109	if (d->stroker.matrix.type() >= QTransform::TxProject) {
	1110	QPaintEngine::drawTextItem(p, textItem);
	1111	return;
	1112	}
	1113
	1114	*d->currentPage << "q\n";
	1115	if(!d->simplePen)
	1116	*d->currentPage << QPdf::generateMatrix(d->stroker.matrix);
	1117
	1118	bool hp = d->hasPen;
	1119	d->hasPen = false;
	1120	QBrush b = d->brush;
	1121	d->brush = d->pen.brush();
	1122	setBrush();
	1123
	1124	const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
	1125	Q_ASSERT(ti.fontEngine->type() != QFontEngine::Multi);
	1126	d->drawTextItem(p, ti);
	1127	d->hasPen = hp;
	1128	d->brush = b;
	1129	*d->currentPage << "Q\n";
	1130	}
	1131
	1132
	1133	void QPdfBaseEngine::updateState(const QPaintEngineState &state)
	1134	{
	1135	Q_D(QPdfBaseEngine);
	1136
	1137	if (d->useAlphaEngine) {
	1138	QAlphaPaintEngine::updateState(state);
	1139	if (!continueCall())
	1140	return;
	1141	}
	1142
	1143	QPaintEngine::DirtyFlags flags = state.state();
	1144
	1145	if (flags & DirtyTransform)
	1146	d->stroker.matrix = state.transform();
	1147
	1148	if (flags & DirtyPen) {
	1149	d->pen = state.pen();
	1150	d->hasPen = d->pen.style() != Qt::NoPen;
	1151	d->stroker.setPen(d->pen);
	1152	QBrush penBrush = d->pen.brush();
	1153	bool oldSimple = d->simplePen;
	1154	d->simplePen = (d->hasPen && (penBrush.style() == Qt::SolidPattern) && penBrush.isOpaque());
	1155	if (oldSimple != d->simplePen)
	1156	flags \|= DirtyTransform;
	1157	}
	1158	if (flags & DirtyBrush) {
	1159	d->brush = state.brush();
	1160	d->hasBrush = d->brush.style() != Qt::NoBrush;
	1161	}
	1162	if (flags & DirtyBrushOrigin) {
	1163	d->brushOrigin = state.brushOrigin();
	1164	flags \|= DirtyBrush;
	1165	}
	1166	if (flags & DirtyOpacity)
	1167	d->opacity = state.opacity();
	1168
	1169	bool ce = d->clipEnabled;
	1170	if (flags & DirtyClipPath) {
	1171	d->clipEnabled = true;
	1172	updateClipPath(state.clipPath(), state.clipOperation());
	1173	} else if (flags & DirtyClipRegion) {
	1174	d->clipEnabled = true;
	1175	QPainterPath path;
	1176	QVector<QRect> rects = state.clipRegion().rects();
	1177	for (int i = 0; i < rects.size(); ++i)
	1178	path.addRect(rects.at(i));
	1179	updateClipPath(path, state.clipOperation());
	1180	flags \|= DirtyClipPath;
	1181	} else if (flags & DirtyClipEnabled) {
	1182	d->clipEnabled = state.isClipEnabled();
	1183	}
	1184
	1185	if (ce != d->clipEnabled)
	1186	flags \|= DirtyClipPath;
	1187	else if (!d->clipEnabled)
	1188	flags &= ~DirtyClipPath;
	1189
	1190	setupGraphicsState(flags);
	1191	}
	1192
	1193	void QPdfBaseEngine::setupGraphicsState(QPaintEngine::DirtyFlags flags)
	1194	{
	1195	Q_D(QPdfBaseEngine);
	1196	if (flags & DirtyClipPath)
	1197	flags \|= DirtyTransform\|DirtyPen\|DirtyBrush;
	1198
	1199	if (flags & DirtyTransform) {
	1200	*d->currentPage << "Q\n";
	1201	flags \|= DirtyPen\|DirtyBrush;
	1202	}
	1203
	1204	if (flags & DirtyClipPath) {
	1205	*d->currentPage << "Q q\n";
	1206
	1207	d->allClipped = false;
	1208	if (d->clipEnabled && !d->clips.isEmpty()) {
	1209	for (int i = 0; i < d->clips.size(); ++i) {
	1210	if (d->clips.at(i).isEmpty()) {
	1211	d->allClipped = true;
	1212	break;
	1213	}
	1214	}
	1215	if (!d->allClipped) {
	1216	for (int i = 0; i < d->clips.size(); ++i) {
	1217	*d->currentPage << QPdf::generatePath(d->clips.at(i), QTransform(), QPdf::ClipPath);
	1218	}
	1219	}
	1220	}
	1221	}
	1222
	1223	if (flags & DirtyTransform) {
	1224	*d->currentPage << "q\n";
	1225	if (d->simplePen && !d->stroker.matrix.isIdentity())
	1226	*d->currentPage << QPdf::generateMatrix(d->stroker.matrix);
	1227	}
	1228	if (flags & DirtyBrush)
	1229	setBrush();
	1230	if (d->simplePen && (flags & DirtyPen))
	1231	setPen();
	1232	}
	1233
	1234	extern QPainterPath qt_regionToPath(const QRegion &region);
	1235
	1236	void QPdfBaseEngine::updateClipPath(const QPainterPath &p, Qt::ClipOperation op)
	1237	{
	1238	Q_D(QPdfBaseEngine);
	1239	QPainterPath path = d->stroker.matrix.map(p);
	1240	//qDebug() << "updateClipPath: " << d->stroker.matrix << p.boundingRect() << path.boundingRect() << op;
	1241
	1242	if (op == Qt::NoClip) {
	1243	d->clipEnabled = false;
	1244	d->clips.clear();
	1245	} else if (op == Qt::ReplaceClip) {
	1246	d->clips.clear();
	1247	d->clips.append(path);
	1248	} else if (op == Qt::IntersectClip) {
	1249	d->clips.append(path);
	1250	} else { // UniteClip
	1251	// ask the painter for the current clipping path. that's the easiest solution
	1252	path = painter()->clipPath();
	1253	path = d->stroker.matrix.map(path);
	1254	d->clips.clear();
	1255	d->clips.append(path);
	1256	}
	1257
	1258	if (d->useAlphaEngine) {
	1259	// if we have an alpha region, we have to subtract that from the
	1260	// any existing clip region since that region will be filled in
	1261	// later with images
	1262	QPainterPath alphaClip = qt_regionToPath(alphaClipping());
	1263	if (!alphaClip.isEmpty()) {
	1264	if (!d->clipEnabled) {
	1265	QRect r = d->fullPage ? d->paperRect() : d->pageRect();
	1266	QPainterPath dev;
	1267	dev.addRect(QRect(0, 0, r.width(), r.height()));
	1268	if (path.isEmpty())
	1269	path = dev;
	1270	else
	1271	path = path.intersected(dev);
	1272	d->clipEnabled = true;
	1273	} else {
	1274	path = painter()->clipPath();
	1275	path = d->stroker.matrix.map(path);
	1276	}
	1277	path = path.subtracted(alphaClip);
	1278	d->clips.clear();
	1279	d->clips.append(path);
	1280	}
	1281	}
	1282	}
	1283
	1284	void QPdfBaseEngine::setPen()
	1285	{
	1286	Q_D(QPdfBaseEngine);
	1287	if (d->pen.style() == Qt::NoPen)
	1288	return;
	1289	QBrush b = d->pen.brush();
	1290	Q_ASSERT(b.style() == Qt::SolidPattern && b.isOpaque());
	1291
	1292	QColor rgba = b.color();
	1293	if (d->colorMode == QPrinter::GrayScale) {
	1294	qreal gray = qGray(rgba.rgba())/255.;
	1295	*d->currentPage << gray << gray << gray;
	1296	} else {
	1297	*d->currentPage << rgba.redF()
	1298	<< rgba.greenF()
	1299	<< rgba.blueF();
	1300	}
	1301	*d->currentPage << "SCN\n";
	1302
	1303	*d->currentPage << d->pen.widthF() << "w ";
	1304
	1305	int pdfCapStyle = 0;
	1306	switch(d->pen.capStyle()) {
	1307	case Qt::FlatCap:
	1308	pdfCapStyle = 0;
	1309	break;
	1310	case Qt::SquareCap:
	1311	pdfCapStyle = 2;
	1312	break;
	1313	case Qt::RoundCap:
	1314	pdfCapStyle = 1;
	1315	break;
	1316	default:
	1317	break;
	1318	}
	1319	*d->currentPage << pdfCapStyle << "J ";
	1320
	1321	int pdfJoinStyle = 0;
	1322	switch(d->pen.joinStyle()) {
	1323	case Qt::MiterJoin:
	1324	pdfJoinStyle = 0;
	1325	break;
	1326	case Qt::BevelJoin:
	1327	pdfJoinStyle = 2;
	1328	break;
	1329	case Qt::RoundJoin:
	1330	pdfJoinStyle = 1;
	1331	break;
	1332	default:
	1333	break;
	1334	}
	1335	*d->currentPage << pdfJoinStyle << "j ";
	1336
	1337	*d->currentPage << QPdf::generateDashes(d->pen) << " 0 d\n";
	1338	}
	1339
	1340	bool QPdfBaseEngine::newPage()
	1341	{
	1342	Q_D(QPdfBaseEngine);
	1343	setupGraphicsState(DirtyBrush\|DirtyPen\|DirtyClipPath);
	1344	QFile outfile = qobject_cast<QFile> (d->outDevice);
	1345	if (outfile && outfile->error() != QFile::NoError)
	1346	return false;
	1347	return true;
	1348	}
	1349
	1350
	1351	int QPdfBaseEngine::metric(QPaintDevice::PaintDeviceMetric metricType) const
	1352	{
	1353	Q_D(const QPdfBaseEngine);
	1354	int val;
	1355	QRect r = d->fullPage ? d->paperRect() : d->pageRect();
	1356	switch (metricType) {
	1357	case QPaintDevice::PdmWidth:
	1358	val = r.width();
	1359	break;
	1360	case QPaintDevice::PdmHeight:
	1361	val = r.height();
	1362	break;
	1363	case QPaintDevice::PdmDpiX:
	1364	case QPaintDevice::PdmDpiY:
	1365	val = d->resolution;
	1366	break;
	1367	case QPaintDevice::PdmPhysicalDpiX:
	1368	case QPaintDevice::PdmPhysicalDpiY:
	1369	val = 1200;
	1370	break;
	1371	case QPaintDevice::PdmWidthMM:
	1372	val = qRound(r.width()*25.4/d->resolution);
	1373	break;
	1374	case QPaintDevice::PdmHeightMM:
	1375	val = qRound(r.height()*25.4/d->resolution);
	1376	break;
	1377	case QPaintDevice::PdmNumColors:
	1378	val = INT_MAX;
	1379	break;
	1380	case QPaintDevice::PdmDepth:
	1381	val = 32;
	1382	break;
	1383	default:
	1384	qWarning("QPrinter::metric: Invalid metric command");
	1385	return 0;
	1386	}
	1387	return val;
	1388	}
	1389
	1390	void QPdfBaseEngine::setProperty(PrintEnginePropertyKey key, const QVariant &value)
	1391	{
	1392	Q_D(QPdfBaseEngine);
[846]	1393	switch (int(key)) {
[2]	1394	case PPK_CollateCopies:
	1395	d->collate = value.toBool();
	1396	break;
	1397	case PPK_ColorMode:
	1398	d->colorMode = QPrinter::ColorMode(value.toInt());
	1399	break;
	1400	case PPK_Creator:
	1401	d->creator = value.toString();
	1402	break;
	1403	case PPK_DocumentName:
	1404	d->title = value.toString();
	1405	break;
	1406	case PPK_FullPage:
	1407	d->fullPage = value.toBool();
	1408	break;
[846]	1409	case PPK_CopyCount: // fallthrough
[2]	1410	case PPK_NumberOfCopies:
	1411	d->copies = value.toInt();
	1412	break;
	1413	case PPK_Orientation:
	1414	d->orientation = QPrinter::Orientation(value.toInt());
	1415	break;
	1416	case PPK_OutputFileName:
	1417	d->outputFileName = value.toString();
	1418	break;
	1419	case PPK_PageOrder:
	1420	d->pageOrder = QPrinter::PageOrder(value.toInt());
	1421	break;
	1422	case PPK_PaperSize:
	1423	d->paperSize = QPrinter::PaperSize(value.toInt());
	1424	break;
	1425	case PPK_PaperSource:
	1426	d->paperSource = QPrinter::PaperSource(value.toInt());
	1427	break;
	1428	case PPK_PrinterName:
	1429	d->printerName = value.toString();
	1430	break;
	1431	case PPK_PrinterProgram:
	1432	d->printProgram = value.toString();
	1433	break;
	1434	case PPK_Resolution:
	1435	d->resolution = value.toInt();
	1436	break;
	1437	case PPK_SelectionOption:
	1438	d->selectionOption = value.toString();
	1439	break;
	1440	case PPK_FontEmbedding:
	1441	d->embedFonts = value.toBool();
	1442	break;
	1443	case PPK_Duplex:
	1444	d->duplex = static_cast<QPrinter::DuplexMode> (value.toInt());
	1445	break;
	1446	case PPK_CupsPageRect:
	1447	d->cupsPageRect = value.toRect();
	1448	break;
	1449	case PPK_CupsPaperRect:
	1450	d->cupsPaperRect = value.toRect();
	1451	break;
	1452	case PPK_CupsOptions:
	1453	d->cupsOptions = value.toStringList();
	1454	break;
	1455	case PPK_CupsStringPageSize:
	1456	d->cupsStringPageSize = value.toString();
	1457	break;
	1458	case PPK_CustomPaperSize:
	1459	d->paperSize = QPrinter::Custom;
	1460	d->customPaperSize = value.toSizeF();
	1461	break;
	1462	case PPK_PageMargins:
	1463	{
	1464	QList<QVariant> margins(value.toList());
	1465	Q_ASSERT(margins.size() == 4);
[561]	1466	d->leftMargin = margins.at(0).toReal();
	1467	d->topMargin = margins.at(1).toReal();
	1468	d->rightMargin = margins.at(2).toReal();
	1469	d->bottomMargin = margins.at(3).toReal();
[2]	1470	d->hasCustomPageMargins = true;
	1471	break;
	1472	}
	1473	default:
	1474	break;
	1475	}
	1476	}
	1477
	1478	QVariant QPdfBaseEngine::property(PrintEnginePropertyKey key) const
	1479	{
	1480	Q_D(const QPdfBaseEngine);
	1481
	1482	QVariant ret;
[846]	1483	switch (int(key)) {
[2]	1484	case PPK_CollateCopies:
	1485	ret = d->collate;
	1486	break;
	1487	case PPK_ColorMode:
	1488	ret = d->colorMode;
	1489	break;
	1490	case PPK_Creator:
	1491	ret = d->creator;
	1492	break;
	1493	case PPK_DocumentName:
	1494	ret = d->title;
	1495	break;
	1496	case PPK_FullPage:
	1497	ret = d->fullPage;
	1498	break;
[846]	1499	case PPK_CopyCount:
	1500	ret = d->copies;
	1501	break;
	1502	case PPK_SupportsMultipleCopies:
	1503	#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
	1504	if (QCUPSSupport::isAvailable())
	1505	ret = true;
	1506	else
	1507	#endif
	1508	ret = false;
	1509	break;
[2]	1510	case PPK_NumberOfCopies:
[573]	1511	#if !defined(QT_NO_CUPS) && (!defined(QT_NO_LIBRARY) \|\| defined(Q_WS_PM))
[2]	1512	if (QCUPSSupport::isAvailable())
	1513	ret = 1;
	1514	else
	1515	#endif
	1516	ret = d->copies;
	1517	break;
	1518	case PPK_Orientation:
	1519	ret = d->orientation;
	1520	break;
	1521	case PPK_OutputFileName:
	1522	ret = d->outputFileName;
	1523	break;
	1524	case PPK_PageOrder:
	1525	ret = d->pageOrder;
	1526	break;
	1527	case PPK_PaperSize:
	1528	ret = d->paperSize;
	1529	break;
	1530	case PPK_PaperSource:
	1531	ret = d->paperSource;
	1532	break;
	1533	case PPK_PrinterName:
	1534	ret = d->printerName;
	1535	break;
	1536	case PPK_PrinterProgram:
	1537	ret = d->printProgram;
	1538	break;
	1539	case PPK_Resolution:
	1540	ret = d->resolution;
	1541	break;
	1542	case PPK_SupportedResolutions:
	1543	ret = QList<QVariant>() << 72;
	1544	break;
	1545	case PPK_PaperRect:
	1546	ret = d->paperRect();
	1547	break;
	1548	case PPK_PageRect:
	1549	ret = d->pageRect();
	1550	break;
	1551	case PPK_SelectionOption:
	1552	ret = d->selectionOption;
	1553	break;
	1554	case PPK_FontEmbedding:
	1555	ret = d->embedFonts;
	1556	break;
	1557	case PPK_Duplex:
	1558	ret = d->duplex;
	1559	break;
	1560	case PPK_CupsPageRect:
	1561	ret = d->cupsPageRect;
	1562	break;
	1563	case PPK_CupsPaperRect:
	1564	ret = d->cupsPaperRect;
	1565	break;
	1566	case PPK_CupsOptions:
	1567	ret = d->cupsOptions;
	1568	break;
	1569	case PPK_CupsStringPageSize:
	1570	ret = d->cupsStringPageSize;
	1571	break;
	1572	case PPK_CustomPaperSize:
	1573	ret = d->customPaperSize;
	1574	break;
	1575	case PPK_PageMargins:
	1576	{
	1577	QList<QVariant> margins;
	1578	if (d->hasCustomPageMargins) {
	1579	margins << d->leftMargin << d->topMargin
	1580	<< d->rightMargin << d->bottomMargin;
	1581	} else {
[561]	1582	const qreal defaultMargin = 10; // ~3.5 mm
[2]	1583	margins << defaultMargin << defaultMargin
	1584	<< defaultMargin << defaultMargin;
	1585	}
	1586	ret = margins;
	1587	break;
	1588	}
	1589	default:
	1590	break;
	1591	}
	1592	return ret;
	1593	}
	1594
	1595	QPdfBaseEnginePrivate::QPdfBaseEnginePrivate(QPrinter::PrinterMode m)
	1596	: clipEnabled(false), allClipped(false), hasPen(true), hasBrush(false), simplePen(false),
	1597	useAlphaEngine(false),
	1598	outDevice(0), fd(-1),
	1599	duplex(QPrinter::DuplexNone), collate(false), fullPage(false), embedFonts(true), copies(1),
	1600	pageOrder(QPrinter::FirstPageFirst), orientation(QPrinter::Portrait),
	1601	paperSize(QPrinter::A4), colorMode(QPrinter::Color), paperSource(QPrinter::Auto),
	1602	hasCustomPageMargins(false),
	1603	leftMargin(0), topMargin(0), rightMargin(0), bottomMargin(0)
	1604	{
	1605	resolution = 72;
	1606	if (m == QPrinter::HighResolution)
	1607	resolution = 1200;
	1608	else if (m == QPrinter::ScreenResolution)
	1609	resolution = qt_defaultDpi();
	1610
	1611	postscript = false;
	1612	currentObject = 1;
	1613	currentPage = 0;
	1614	stroker.stream = 0;
	1615	}
	1616
	1617	bool QPdfBaseEngine::begin(QPaintDevice *pdev)
	1618	{
	1619	Q_D(QPdfBaseEngine);
	1620	d->pdev = pdev;
	1621
	1622	d->postscript = false;
	1623	d->currentObject = 1;
	1624
	1625	d->currentPage = new QPdfPage;
	1626	d->stroker.stream = d->currentPage;
	1627	d->opacity = 1.0;
	1628
	1629	return d->openPrintDevice();
	1630	}
	1631
	1632	bool QPdfBaseEngine::end()
	1633	{
	1634	Q_D(QPdfBaseEngine);
	1635	qDeleteAll(d->fonts);
	1636	d->fonts.clear();
	1637	delete d->currentPage;
	1638	d->currentPage = 0;
	1639
	1640	d->closePrintDevice();
	1641	return true;
	1642	}
	1643
	1644	#ifndef QT_NO_LPR
	1645	static void closeAllOpenFds()
	1646	{
	1647	// hack time... getting the maximum number of open
	1648	// files, if possible. if not we assume it's the
	1649	// larger of 256 and the fd we got
	1650	int i;
	1651	#if defined(_SC_OPEN_MAX)
	1652	i = (int)sysconf(_SC_OPEN_MAX);
	1653	#elif defined(_POSIX_OPEN_MAX)
	1654	i = (int)_POSIX_OPEN_MAX;
	1655	#elif defined(OPEN_MAX)
	1656	i = (int)OPEN_MAX;
	1657	#else
	1658	i = 256;
	1659	#endif
	1660	// leave stdin/out/err untouched
	1661	while(--i > 2)
[561]	1662	QT_CLOSE(i);
[2]	1663	}
	1664	#endif
	1665
	1666	bool QPdfBaseEnginePrivate::openPrintDevice()
	1667	{
	1668	if(outDevice)
	1669	return false;
	1670
	1671	if (!outputFileName.isEmpty()) {
	1672	QFile *file = new QFile(outputFileName);
	1673	if (! file->open(QFile::WriteOnly\|QFile::Truncate)) {
	1674	delete file;
	1675	return false;
	1676	}
	1677	outDevice = file;
[573]	1678	#if !defined(QT_NO_CUPS) && (!defined(QT_NO_LIBRARY) \|\| defined(Q_WS_PM))
[2]	1679	} else if (QCUPSSupport::isAvailable()) {
	1680	QCUPSSupport cups;
	1681	QPair<int, QString> ret = cups.tempFd();
	1682	if (ret.first < 0) {
	1683	qWarning("QPdfPrinter: Could not open temporary file to print");
	1684	return false;
	1685	}
[781]	1686	#if defined(Q_WS_PM)
	1687	// some CUPS versions don't set the mode of the returned fd to O_BINARY
	1688	// which is vital for correct PDF generation (consider binary blocks);
	1689	// force it here
	1690	::setmode(ret.first, O_BINARY);
	1691	#endif
[2]	1692	cupsTempFile = ret.second;
	1693	outDevice = new QFile();
	1694	static_cast<QFile *>(outDevice)->open(ret.first, QIODevice::WriteOnly);
[574]	1695	// save fd to get the temporary file closed in closePrintDevice()
	1696	fd = ret.first;
[2]	1697	#endif
	1698	#ifndef QT_NO_LPR
	1699	} else {
	1700	QString pr;
	1701	if (!printerName.isEmpty())
	1702	pr = printerName;
	1703	int fds[2];
[561]	1704	if (qt_safe_pipe(fds) != 0) {
[2]	1705	qWarning("QPdfPrinter: Could not open pipe to print");
	1706	return false;
	1707	}
	1708
	1709	pid_t pid = fork();
	1710	if (pid == 0) { // child process
	1711	// if possible, exit quickly, so the actual lp/lpr
	1712	// becomes a child of init, and ::waitpid() is
	1713	// guaranteed not to wait.
	1714	if (fork() > 0) {
	1715	closeAllOpenFds();
	1716
	1717	// try to replace this process with "true" - this prevents
	1718	// global destructors from being called (that could possibly
	1719	// do wrong things to the parent process)
	1720	(void)execlp("true", "true", (char *)0);
	1721	(void)execl("/bin/true", "true", (char *)0);
	1722	(void)execl("/usr/bin/true", "true", (char *)0);
[561]	1723	::_exit(0);
[2]	1724	}
[561]	1725	qt_safe_dup2(fds[0], 0, 0);
[2]	1726
	1727	closeAllOpenFds();
	1728
	1729	if (!printProgram.isEmpty()) {
	1730	if (!selectionOption.isEmpty())
	1731	pr.prepend(selectionOption);
	1732	else
	1733	pr.prepend(QLatin1String("-P"));
	1734	(void)execlp(printProgram.toLocal8Bit().data(), printProgram.toLocal8Bit().data(),
	1735	pr.toLocal8Bit().data(), (char *)0);
	1736	} else {
	1737	// if no print program has been specified, be smart
	1738	// about the option string too.
	1739	QList<QByteArray> lprhack;
	1740	QList<QByteArray> lphack;
	1741	QByteArray media;
	1742	if (!pr.isEmpty() \|\| !selectionOption.isEmpty()) {
	1743	if (!selectionOption.isEmpty()) {
	1744	QStringList list = selectionOption.split(QLatin1Char(' '));
	1745	for (int i = 0; i < list.size(); ++i)
	1746	lprhack.append(list.at(i).toLocal8Bit());
	1747	lphack = lprhack;
	1748	} else {
	1749	lprhack.append("-P");
	1750	lphack.append("-d");
	1751	}
	1752	lprhack.append(pr.toLocal8Bit());
	1753	lphack.append(pr.toLocal8Bit());
	1754	}
	1755	lphack.append("-s");
	1756
	1757	char ** lpargs = new char *[lphack.size()+6];
	1758	char lp[] = "lp";
	1759	lpargs[0] = lp;
	1760	int i;
	1761	for (i = 0; i < lphack.size(); ++i)
	1762	lpargs[i+1] = (char *)lphack.at(i).constData();
	1763	#ifndef Q_OS_OSF
	1764	if (QPdf::paperSizeToString(paperSize)) {
	1765	char dash_o[] = "-o";
	1766	lpargs[++i] = dash_o;
	1767	lpargs[++i] = const_cast<char *>(QPdf::paperSizeToString(paperSize));
	1768	lpargs[++i] = dash_o;
	1769	media = "media=";
	1770	media += QPdf::paperSizeToString(paperSize);
	1771	lpargs[++i] = media.data();
	1772	}
	1773	#endif
	1774	lpargs[++i] = 0;
	1775	char *lprargs = new char [lprhack.size()+2];
	1776	char lpr[] = "lpr";
	1777	lprargs[0] = lpr;
	1778	for (int i = 0; i < lprhack.size(); ++i)
	1779	lprargs[i+1] = (char *)lprhack[i].constData();
	1780	lprargs[lprhack.size() + 1] = 0;
	1781	(void)execvp("lp", lpargs);
	1782	(void)execvp("lpr", lprargs);
	1783	(void)execv("/bin/lp", lpargs);
	1784	(void)execv("/bin/lpr", lprargs);
	1785	(void)execv("/usr/bin/lp", lpargs);
	1786	(void)execv("/usr/bin/lpr", lprargs);
[561]	1787
	1788	delete []lpargs;
	1789	delete []lprargs;
[2]	1790	}
	1791	// if we couldn't exec anything, close the fd,
	1792	// wait for a second so the parent process (the
	1793	// child of the GUI process) has exited. then
	1794	// exit.
[561]	1795	QT_CLOSE(0);
[2]	1796	(void)::sleep(1);
[561]	1797	::_exit(0);
[2]	1798	}
	1799	// parent process
[561]	1800	QT_CLOSE(fds[0]);
[2]	1801	fd = fds[1];
[561]	1802	(void)qt_safe_waitpid(pid, 0, 0);
[578]	1803
[2]	1804	if (fd < 0)
	1805	return false;
	1806
	1807	outDevice = new QFile();
	1808	static_cast<QFile *>(outDevice)->open(fd, QIODevice::WriteOnly);
	1809	#endif
	1810	}
	1811
	1812	return true;
	1813	}
	1814
	1815	void QPdfBaseEnginePrivate::closePrintDevice()
	1816	{
	1817	if (!outDevice)
	1818	return;
	1819	outDevice->close();
	1820	if (fd >= 0)
	1821	#if defined(Q_OS_WIN) && defined(_MSC_VER) && _MSC_VER >= 1400
	1822	::_close(fd);
	1823	#else
	1824	::close(fd);
	1825	#endif
	1826	fd = -1;
	1827	delete outDevice;
	1828	outDevice = 0;
	1829
[573]	1830	#if !defined(QT_NO_CUPS) && (!defined(QT_NO_LIBRARY) \|\| defined(Q_WS_PM))
[2]	1831	if (!cupsTempFile.isEmpty()) {
	1832	QString tempFile = cupsTempFile;
	1833	cupsTempFile.clear();
	1834	QCUPSSupport cups;
	1835
	1836	// Set up print options.
	1837	QByteArray prnName;
	1838	QList<QPair<QByteArray, QByteArray> > options;
	1839	QVector<cups_option_t> cupsOptStruct;
	1840
	1841	if (!printerName.isEmpty()) {
	1842	prnName = printerName.toLocal8Bit();
	1843	} else {
	1844	QPrinterInfo def = QPrinterInfo::defaultPrinter();
	1845	if (def.isNull()) {
	1846	qWarning("Could not determine printer to print to");
	1847	QFile::remove(tempFile);
	1848	return;
	1849	}
	1850	prnName = def.printerName().toLocal8Bit();
	1851	}
	1852
	1853	if (!cupsStringPageSize.isEmpty()) {
	1854	options.append(QPair<QByteArray, QByteArray>("media", cupsStringPageSize.toLocal8Bit()));
	1855	}
	1856
	1857	if (copies > 1) {
	1858	options.append(QPair<QByteArray, QByteArray>("copies", QString::number(copies).toLocal8Bit()));
	1859	}
	1860
	1861	if (collate) {
	1862	options.append(QPair<QByteArray, QByteArray>("Collate", "True"));
	1863	}
	1864
	1865	if (duplex != QPrinter::DuplexNone) {
	1866	switch(duplex) {
	1867	case QPrinter::DuplexNone: break;
	1868	case QPrinter::DuplexAuto:
	1869	if (orientation == QPrinter::Portrait)
	1870	options.append(QPair<QByteArray, QByteArray>("sides", "two-sided-long-edge"));
	1871	else
	1872	options.append(QPair<QByteArray, QByteArray>("sides", "two-sided-short-edge"));
	1873	break;
	1874	case QPrinter::DuplexLongSide:
	1875	options.append(QPair<QByteArray, QByteArray>("sides", "two-sided-long-edge"));
	1876	break;
	1877	case QPrinter::DuplexShortSide:
	1878	options.append(QPair<QByteArray, QByteArray>("sides", "two-sided-short-edge"));
	1879	break;
	1880	}
	1881	}
	1882
	1883	if (QCUPSSupport::cupsVersion() >= 10300 && orientation == QPrinter::Landscape) {
	1884	options.append(QPair<QByteArray, QByteArray>("landscape", ""));
	1885	}
	1886
	1887	QStringList::const_iterator it = cupsOptions.constBegin();
	1888	while (it != cupsOptions.constEnd()) {
	1889	options.append(QPair<QByteArray, QByteArray>((it).toLocal8Bit(), ((it+1)).toLocal8Bit()));
	1890	it += 2;
	1891	}
	1892
	1893	for (int c = 0; c < options.size(); ++c) {
	1894	cups_option_t opt;
	1895	opt.name = options[c].first.data();
	1896	opt.value = options[c].second.data();
	1897	cupsOptStruct.append(opt);
	1898	}
	1899
	1900	// Print the file.
	1901	cups_option_t* optPtr = cupsOptStruct.size() ? &cupsOptStruct.first() : 0;
	1902	cups.printFile(prnName.constData(), tempFile.toLocal8Bit().constData(),
	1903	title.toLocal8Bit().constData(), cupsOptStruct.size(), optPtr);
	1904
	1905	QFile::remove(tempFile);
	1906	}
	1907	#endif
	1908	}
	1909
	1910	QPdfBaseEnginePrivate::~QPdfBaseEnginePrivate()
	1911	{
	1912	qDeleteAll(fonts);
	1913	delete currentPage;
	1914	}
	1915
	1916	void QPdfBaseEnginePrivate::drawTextItem(const QPointF &p, const QTextItemInt &ti)
	1917	{
	1918	Q_Q(QPdfBaseEngine);
	1919
	1920	QFontEngine *fe = ti.fontEngine;
	1921
	1922	QFontEngine::FaceId face_id = fe->faceId();
	1923	bool noEmbed = false;
	1924	if (face_id.filename.isEmpty()
	1925	\|\| (!postscript && ((fe->fsType & 0x200) /* bitmap embedding only */
	1926	\|\| (fe->fsType == 2) /* no embedding allowed */))) {
	1927	*currentPage << "Q\n";
	1928	q->QPaintEngine::drawTextItem(p, ti);
	1929	*currentPage << "q\n";
	1930	if (face_id.filename.isEmpty())
	1931	return;
	1932	noEmbed = true;
	1933	}
	1934
	1935	QFontSubset *font = fonts.value(face_id, 0);
	1936	if (!font) {
	1937	font = new QFontSubset(fe, requestObject());
	1938	font->noEmbed = noEmbed;
	1939	}
	1940	fonts.insert(face_id, font);
	1941
	1942	if (!currentPage->fonts.contains(font->object_id))
	1943	currentPage->fonts.append(font->object_id);
	1944
	1945	qreal size = ti.fontEngine->fontDef.pixelSize;
	1946	#ifdef Q_WS_WIN
	1947	if (ti.fontEngine->type() == QFontEngine::Win) {
	1948	QFontEngineWin fe = static_cast<QFontEngineWin >(ti.fontEngine);
[561]	1949	size = fe->tm.tmHeight;
[2]	1950	}
	1951	#endif
	1952
	1953	QVarLengthArray<glyph_t> glyphs;
	1954	QVarLengthArray<QFixedPoint> positions;
[561]	1955	QTransform m = QTransform::fromTranslate(p.x(), p.y());
[2]	1956	ti.fontEngine->getGlyphPositions(ti.glyphs, m, ti.flags,
	1957	glyphs, positions);
	1958	if (glyphs.size() == 0)
	1959	return;
	1960	int synthesized = ti.fontEngine->synthesized();
	1961	qreal stretch = synthesized & QFontEngine::SynthesizedStretch ? ti.fontEngine->fontDef.stretch/100. : 1.;
	1962
	1963	*currentPage << "BT\n"
	1964	<< "/F" << font->object_id << size << "Tf "
	1965	<< stretch << (synthesized & QFontEngine::SynthesizedItalic
	1966	? "0 .3 -1 0 0 Tm\n"
	1967	: "0 0 -1 0 0 Tm\n");
	1968
	1969
	1970	#if 0
	1971	// #### implement actual text for complex languages
	1972	const unsigned short *logClusters = ti.logClusters;
	1973	int pos = 0;
	1974	do {
	1975	int end = pos + 1;
	1976	while (end < ti.num_chars && logClusters[end] == logClusters[pos])
	1977	++end;
	1978	*currentPage << "/Span << /ActualText <FEFF";
	1979	for (int i = pos; i < end; ++i) {
	1980	s << toHex((ushort)ti.chars[i].unicode(), buf);
	1981	}
	1982	*currentPage << "> >>\n"
	1983	"BDC\n"
	1984	"<";
	1985	int ge = end == ti.num_chars ? ti.num_glyphs : logClusters[end];
	1986	for (int gs = logClusters[pos]; gs < ge; ++gs)
	1987	*currentPage << toHex((ushort)ti.glyphs[gs].glyph, buf);
	1988	*currentPage << "> Tj\n"
	1989	"EMC\n";
	1990	pos = end;
	1991	} while (pos < ti.num_chars);
	1992	#else
	1993	qreal last_x = 0.;
	1994	qreal last_y = 0.;
	1995	for (int i = 0; i < glyphs.size(); ++i) {
	1996	qreal x = positions[i].x.toReal();
	1997	qreal y = positions[i].y.toReal();
	1998	if (synthesized & QFontEngine::SynthesizedItalic)
	1999	x += .3*y;
	2000	x /= stretch;
	2001	char buf[5];
	2002	int g = font->addGlyph(glyphs[i]);
	2003	*currentPage << x - last_x << last_y - y << "Td <"
	2004	<< QPdf::toHex((ushort)g, buf) << "> Tj\n";
	2005	last_x = x;
	2006	last_y = y;
	2007	}
	2008	if (synthesized & QFontEngine::SynthesizedBold) {
	2009	*currentPage << stretch << (synthesized & QFontEngine::SynthesizedItalic
	2010	? "0 .3 -1 0 0 Tm\n"
	2011	: "0 0 -1 0 0 Tm\n");
	2012	*currentPage << "/Span << /ActualText <> >> BDC\n";
	2013	last_x = 0.5*fe->lineThickness().toReal();
	2014	last_y = 0.;
	2015	for (int i = 0; i < glyphs.size(); ++i) {
	2016	qreal x = positions[i].x.toReal();
	2017	qreal y = positions[i].y.toReal();
	2018	if (synthesized & QFontEngine::SynthesizedItalic)
	2019	x += .3*y;
	2020	x /= stretch;
	2021	char buf[5];
	2022	int g = font->addGlyph(glyphs[i]);
	2023	*currentPage << x - last_x << last_y - y << "Td <"
	2024	<< QPdf::toHex((ushort)g, buf) << "> Tj\n";
	2025	last_x = x;
	2026	last_y = y;
	2027	}
	2028	*currentPage << "EMC\n";
	2029	}
	2030	#endif
	2031
	2032	*currentPage << "ET\n";
	2033	}
	2034
	2035	QRect QPdfBaseEnginePrivate::paperRect() const
	2036	{
	2037	int w;
	2038	int h;
	2039	if (paperSize == QPrinter::Custom) {
	2040	w = qRound(customPaperSize.width()*resolution/72.);
	2041	h = qRound(customPaperSize.height()*resolution/72.);
	2042	} else {
[573]	2043	#if !defined(QT_NO_CUPS) && (!defined(QT_NO_LIBRARY) \|\| defined(Q_WS_PM))
[2]	2044	if (QCUPSSupport::isAvailable() && !cupsPaperRect.isNull()) {
	2045	QRect r = cupsPaperRect;
	2046	w = r.width();
	2047	h = r.height();
	2048	} else
	2049	#endif
	2050	{
	2051	QPdf::PaperSize s = QPdf::paperSize(paperSize);
	2052	w = s.width;
	2053	h = s.height;
	2054	}
	2055	w = qRound(w*resolution/72.);
	2056	h = qRound(h*resolution/72.);
	2057	}
	2058	if (orientation == QPrinter::Portrait)
	2059	return QRect(0, 0, w, h);
	2060	else
	2061	return QRect(0, 0, h, w);
	2062	}
	2063
	2064	QRect QPdfBaseEnginePrivate::pageRect() const
	2065	{
	2066	if(fullPage)
	2067	return paperRect();
	2068
	2069	QRect r;
	2070
[573]	2071	#if !defined(QT_NO_CUPS) && (!defined(QT_NO_LIBRARY) \|\| defined(Q_WS_PM))
[2]	2072	if (!hasCustomPageMargins && QCUPSSupport::isAvailable() && !cupsPageRect.isNull()) {
	2073	r = cupsPageRect;
	2074	if (r == cupsPaperRect) {
	2075	// if cups doesn't define any margins, give it at least approx 3.5 mm
	2076	r = QRect(10, 10, r.width() - 20, r.height() - 20);
	2077	}
	2078	} else
	2079	#endif
	2080	{
	2081	QPdf::PaperSize s;
	2082	if (paperSize == QPrinter::Custom) {
	2083	s.width = qRound(customPaperSize.width());
	2084	s.height = qRound(customPaperSize.height());
	2085	} else {
	2086	s = QPdf::paperSize(paperSize);
	2087	}
	2088	if (hasCustomPageMargins)
	2089	r = QRect(0, 0, s.width, s.height);
	2090	else
	2091	r = QRect(72/3, 72/3, s.width - 272/3, s.height - 272/3);
	2092	}
	2093
	2094	int x = qRound(r.left()*resolution/72.);
	2095	int y = qRound(r.top()*resolution/72.);
	2096	int w = qRound(r.width()*resolution/72.);
	2097	int h = qRound(r.height()*resolution/72.);
	2098	if (orientation == QPrinter::Portrait)
	2099	r = QRect(x, y, w, h);
	2100	else
	2101	r = QRect(y, x, h, w);
	2102
	2103	if (hasCustomPageMargins) {
	2104	r.adjust(qRound(leftMargin*(resolution/72.)),
	2105	qRound(topMargin*(resolution/72.)),
	2106	-qRound(rightMargin*(resolution/72.)),
	2107	-qRound(bottomMargin*(resolution/72.)));
	2108	}
	2109	return r;
	2110	}
	2111
	2112	#endif
	2113
	2114	QT_END_NAMESPACE

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/src/gui/painting/qpdf.cpp

Download in other formats: