|
1 /**************************************************************************** |
|
2 ** |
|
3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
4 ** All rights reserved. |
|
5 ** Contact: Nokia Corporation (qt-info@nokia.com) |
|
6 ** |
|
7 ** This file is part of the QtGui module of the Qt Toolkit. |
|
8 ** |
|
9 ** $QT_BEGIN_LICENSE:LGPL$ |
|
10 ** No Commercial Usage |
|
11 ** This file contains pre-release code and may not be distributed. |
|
12 ** You may use this file in accordance with the terms and conditions |
|
13 ** contained in the Technology Preview License Agreement accompanying |
|
14 ** this package. |
|
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 ** |
|
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. |
|
27 ** |
|
28 ** If you have questions regarding the use of this file, please contact |
|
29 ** Nokia at qt-info@nokia.com. |
|
30 ** |
|
31 ** |
|
32 ** |
|
33 ** |
|
34 ** |
|
35 ** |
|
36 ** |
|
37 ** |
|
38 ** $QT_END_LICENSE$ |
|
39 ** |
|
40 ****************************************************************************/ |
|
41 |
|
42 #include "qprintpreviewwidget.h" |
|
43 #include "private/qwidget_p.h" |
|
44 #include <private/qprinter_p.h> |
|
45 |
|
46 #include <QtCore/qmath.h> |
|
47 #include <QtGui/qboxlayout.h> |
|
48 #include <QtGui/qgraphicsitem.h> |
|
49 #include <QtGui/qgraphicsview.h> |
|
50 #include <QtGui/qscrollbar.h> |
|
51 #include <QtGui/qstyleoption.h> |
|
52 |
|
53 #ifndef QT_NO_PRINTPREVIEWWIDGET |
|
54 |
|
55 QT_BEGIN_NAMESPACE |
|
56 |
|
57 namespace { |
|
58 class PageItem : public QGraphicsItem |
|
59 { |
|
60 public: |
|
61 PageItem(int _pageNum, const QPicture* _pagePicture, QSize _paperSize, QRect _pageRect) |
|
62 : pageNum(_pageNum), pagePicture(_pagePicture), |
|
63 paperSize(_paperSize), pageRect(_pageRect) |
|
64 { |
|
65 qreal border = qMax(paperSize.height(), paperSize.width()) / 25; |
|
66 brect = QRectF(QPointF(-border, -border), |
|
67 QSizeF(paperSize)+QSizeF(2*border, 2*border)); |
|
68 setCacheMode(DeviceCoordinateCache); |
|
69 } |
|
70 |
|
71 inline QRectF boundingRect() const |
|
72 { return brect; } |
|
73 |
|
74 inline int pageNumber() const |
|
75 { return pageNum; } |
|
76 |
|
77 void paint(QPainter *painter, const QStyleOptionGraphicsItem *item, QWidget *widget); |
|
78 |
|
79 private: |
|
80 int pageNum; |
|
81 const QPicture* pagePicture; |
|
82 QSize paperSize; |
|
83 QRect pageRect; |
|
84 QRectF brect; |
|
85 }; |
|
86 |
|
87 void PageItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) |
|
88 { |
|
89 Q_UNUSED(widget); |
|
90 |
|
91 #if 0 |
|
92 // Draw item bounding rect, for debugging |
|
93 painter->save(); |
|
94 painter->setPen(QPen(Qt::red, 0)); |
|
95 painter->setBrush(Qt::NoBrush); |
|
96 painter->drawRect(QRectF(-border()+1.0, -border()+1.0, boundingRect().width()-2, boundingRect().height()-2)); |
|
97 painter->restore(); |
|
98 #endif |
|
99 |
|
100 QRectF paperRect(0,0, paperSize.width(), paperSize.height()); |
|
101 |
|
102 // Draw shadow |
|
103 painter->setClipRect(option->exposedRect); |
|
104 qreal shWidth = paperRect.width()/100; |
|
105 QRectF rshadow(paperRect.topRight() + QPointF(0, shWidth), |
|
106 paperRect.bottomRight() + QPointF(shWidth, 0)); |
|
107 QLinearGradient rgrad(rshadow.topLeft(), rshadow.topRight()); |
|
108 rgrad.setColorAt(0.0, QColor(0,0,0,255)); |
|
109 rgrad.setColorAt(1.0, QColor(0,0,0,0)); |
|
110 painter->fillRect(rshadow, QBrush(rgrad)); |
|
111 QRectF bshadow(paperRect.bottomLeft() + QPointF(shWidth, 0), |
|
112 paperRect.bottomRight() + QPointF(0, shWidth)); |
|
113 QLinearGradient bgrad(bshadow.topLeft(), bshadow.bottomLeft()); |
|
114 bgrad.setColorAt(0.0, QColor(0,0,0,255)); |
|
115 bgrad.setColorAt(1.0, QColor(0,0,0,0)); |
|
116 painter->fillRect(bshadow, QBrush(bgrad)); |
|
117 QRectF cshadow(paperRect.bottomRight(), |
|
118 paperRect.bottomRight() + QPointF(shWidth, shWidth)); |
|
119 QRadialGradient cgrad(cshadow.topLeft(), shWidth, cshadow.topLeft()); |
|
120 cgrad.setColorAt(0.0, QColor(0,0,0,255)); |
|
121 cgrad.setColorAt(1.0, QColor(0,0,0,0)); |
|
122 painter->fillRect(cshadow, QBrush(cgrad)); |
|
123 |
|
124 painter->setClipRect(paperRect & option->exposedRect); |
|
125 painter->fillRect(paperRect, Qt::white); |
|
126 if (!pagePicture) |
|
127 return; |
|
128 painter->drawPicture(pageRect.topLeft(), *pagePicture); |
|
129 |
|
130 // Effect: make anything drawn in the margins look washed out. |
|
131 QPainterPath path; |
|
132 path.addRect(paperRect); |
|
133 path.addRect(pageRect); |
|
134 painter->setPen(QPen(Qt::NoPen)); |
|
135 painter->setBrush(QColor(255, 255, 255, 180)); |
|
136 painter->drawPath(path); |
|
137 |
|
138 #if 0 |
|
139 // Draw frame around paper. |
|
140 painter->setPen(QPen(Qt::black, 0)); |
|
141 painter->setBrush(Qt::NoBrush); |
|
142 painter->drawRect(paperRect); |
|
143 #endif |
|
144 |
|
145 // todo: drawtext "Page N" below paper |
|
146 } |
|
147 |
|
148 class GraphicsView : public QGraphicsView |
|
149 { |
|
150 Q_OBJECT |
|
151 public: |
|
152 GraphicsView(QWidget* parent = 0) |
|
153 : QGraphicsView(parent) |
|
154 {} |
|
155 signals: |
|
156 void resized(); |
|
157 |
|
158 protected: |
|
159 void resizeEvent(QResizeEvent* e) |
|
160 { |
|
161 QGraphicsView::resizeEvent(e); |
|
162 emit resized(); |
|
163 } |
|
164 |
|
165 void showEvent(QShowEvent* e) |
|
166 { |
|
167 QGraphicsView::showEvent(e); |
|
168 emit resized(); |
|
169 } |
|
170 }; |
|
171 |
|
172 } // anonymous namespace |
|
173 |
|
174 class QPrintPreviewWidgetPrivate : public QWidgetPrivate |
|
175 { |
|
176 Q_DECLARE_PUBLIC(QPrintPreviewWidget) |
|
177 public: |
|
178 QPrintPreviewWidgetPrivate() |
|
179 : scene(0), curPage(1), |
|
180 viewMode(QPrintPreviewWidget::SinglePageView), |
|
181 zoomMode(QPrintPreviewWidget::FitInView), |
|
182 zoomFactor(1), initialized(false), fitting(true) |
|
183 {} |
|
184 |
|
185 // private slots |
|
186 void _q_fit(bool doFitting = false); |
|
187 void _q_updateCurrentPage(); |
|
188 |
|
189 void init(); |
|
190 void populateScene(); |
|
191 void layoutPages(); |
|
192 void generatePreview(); |
|
193 void setCurrentPage(int pageNumber); |
|
194 void zoom(qreal zoom); |
|
195 void setZoomFactor(qreal zoomFactor); |
|
196 int calcCurrentPage(); |
|
197 |
|
198 GraphicsView *graphicsView; |
|
199 QGraphicsScene *scene; |
|
200 |
|
201 int curPage; |
|
202 QList<const QPicture *> pictures; |
|
203 QList<QGraphicsItem *> pages; |
|
204 |
|
205 QPrintPreviewWidget::ViewMode viewMode; |
|
206 QPrintPreviewWidget::ZoomMode zoomMode; |
|
207 qreal zoomFactor; |
|
208 bool ownPrinter; |
|
209 QPrinter* printer; |
|
210 bool initialized; |
|
211 bool fitting; |
|
212 }; |
|
213 |
|
214 void QPrintPreviewWidgetPrivate::_q_fit(bool doFitting) |
|
215 { |
|
216 Q_Q(QPrintPreviewWidget); |
|
217 |
|
218 if (curPage < 1 || curPage > pages.count()) |
|
219 return; |
|
220 |
|
221 if (!doFitting && !fitting) |
|
222 return; |
|
223 |
|
224 if (doFitting && fitting) { |
|
225 QRect viewRect = graphicsView->viewport()->rect(); |
|
226 if (zoomMode == QPrintPreviewWidget::FitInView) { |
|
227 QList<QGraphicsItem*> containedItems = graphicsView->items(viewRect, Qt::ContainsItemBoundingRect); |
|
228 foreach(QGraphicsItem* item, containedItems) { |
|
229 PageItem* pg = static_cast<PageItem*>(item); |
|
230 if (pg->pageNumber() == curPage) |
|
231 return; |
|
232 } |
|
233 } |
|
234 |
|
235 int newPage = calcCurrentPage(); |
|
236 if (newPage != curPage) |
|
237 curPage = newPage; |
|
238 } |
|
239 |
|
240 QRectF target = pages.at(curPage-1)->sceneBoundingRect(); |
|
241 if (viewMode == QPrintPreviewWidget::FacingPagesView) { |
|
242 // fit two pages |
|
243 if (curPage % 2) |
|
244 target.setLeft(target.left() - target.width()); |
|
245 else |
|
246 target.setRight(target.right() + target.width()); |
|
247 } else if (viewMode == QPrintPreviewWidget::AllPagesView) { |
|
248 target = scene->itemsBoundingRect(); |
|
249 } |
|
250 |
|
251 if (zoomMode == QPrintPreviewWidget::FitToWidth) { |
|
252 QTransform t; |
|
253 qreal scale = graphicsView->viewport()->width() / target.width(); |
|
254 t.scale(scale, scale); |
|
255 graphicsView->setTransform(t); |
|
256 if (doFitting && fitting) { |
|
257 QRectF viewSceneRect = graphicsView->viewportTransform().mapRect(graphicsView->viewport()->rect()); |
|
258 viewSceneRect.moveTop(target.top()); |
|
259 graphicsView->ensureVisible(viewSceneRect); // Nah... |
|
260 } |
|
261 } else { |
|
262 graphicsView->fitInView(target, Qt::KeepAspectRatio); |
|
263 if (zoomMode == QPrintPreviewWidget::FitInView) { |
|
264 int step = qRound(graphicsView->matrix().mapRect(target).height()); |
|
265 graphicsView->verticalScrollBar()->setSingleStep(step); |
|
266 graphicsView->verticalScrollBar()->setPageStep(step); |
|
267 } |
|
268 } |
|
269 |
|
270 zoomFactor = graphicsView->transform().m11() * (float(printer->logicalDpiY()) / q->logicalDpiY()); |
|
271 emit q->previewChanged(); |
|
272 } |
|
273 |
|
274 void QPrintPreviewWidgetPrivate::_q_updateCurrentPage() |
|
275 { |
|
276 Q_Q(QPrintPreviewWidget); |
|
277 |
|
278 if (viewMode == QPrintPreviewWidget::AllPagesView) |
|
279 return; |
|
280 |
|
281 int newPage = calcCurrentPage(); |
|
282 if (newPage != curPage) { |
|
283 curPage = newPage; |
|
284 emit q->previewChanged(); |
|
285 } |
|
286 } |
|
287 |
|
288 int QPrintPreviewWidgetPrivate::calcCurrentPage() |
|
289 { |
|
290 int maxArea = 0; |
|
291 int newPage = curPage; |
|
292 QRect viewRect = graphicsView->viewport()->rect(); |
|
293 QList<QGraphicsItem*> items = graphicsView->items(viewRect); |
|
294 for (int i=0; i<items.size(); ++i) { |
|
295 PageItem* pg = static_cast<PageItem*>(items.at(i)); |
|
296 QRect overlap = graphicsView->mapFromScene(pg->sceneBoundingRect()).boundingRect() & viewRect; |
|
297 int area = overlap.width() * overlap.height(); |
|
298 if (area > maxArea) { |
|
299 maxArea = area; |
|
300 newPage = pg->pageNumber(); |
|
301 } else if (area == maxArea && pg->pageNumber() < newPage) { |
|
302 newPage = pg->pageNumber(); |
|
303 } |
|
304 } |
|
305 return newPage; |
|
306 } |
|
307 |
|
308 void QPrintPreviewWidgetPrivate::init() |
|
309 { |
|
310 Q_Q(QPrintPreviewWidget); |
|
311 |
|
312 graphicsView = new GraphicsView; |
|
313 graphicsView->setInteractive(false); |
|
314 graphicsView->setDragMode(QGraphicsView::ScrollHandDrag); |
|
315 graphicsView->setViewportUpdateMode(QGraphicsView::SmartViewportUpdate); |
|
316 QObject::connect(graphicsView->verticalScrollBar(), SIGNAL(valueChanged(int)), |
|
317 q, SLOT(_q_updateCurrentPage())); |
|
318 QObject::connect(graphicsView, SIGNAL(resized()), q, SLOT(_q_fit())); |
|
319 |
|
320 scene = new QGraphicsScene(graphicsView); |
|
321 scene->setBackgroundBrush(Qt::gray); |
|
322 graphicsView->setScene(scene); |
|
323 |
|
324 QVBoxLayout *layout = new QVBoxLayout; |
|
325 q->setLayout(layout); |
|
326 layout->setContentsMargins(0, 0, 0, 0); |
|
327 layout->addWidget(graphicsView); |
|
328 } |
|
329 |
|
330 void QPrintPreviewWidgetPrivate::populateScene() |
|
331 { |
|
332 // remove old pages |
|
333 for (int i = 0; i < pages.size(); i++) |
|
334 scene->removeItem(pages.at(i)); |
|
335 qDeleteAll(pages); |
|
336 pages.clear(); |
|
337 |
|
338 int numPages = pictures.count(); |
|
339 QSize paperSize = printer->paperRect().size(); |
|
340 QRect pageRect = printer->pageRect(); |
|
341 |
|
342 for (int i = 0; i < numPages; i++) { |
|
343 PageItem* item = new PageItem(i+1, pictures.at(i), paperSize, pageRect); |
|
344 scene->addItem(item); |
|
345 pages.append(item); |
|
346 } |
|
347 } |
|
348 |
|
349 void QPrintPreviewWidgetPrivate::layoutPages() |
|
350 { |
|
351 int numPages = pages.count(); |
|
352 if (numPages < 1) |
|
353 return; |
|
354 |
|
355 int numPagePlaces = numPages; |
|
356 int cols = 1; // singleMode and default |
|
357 if (viewMode == QPrintPreviewWidget::AllPagesView) { |
|
358 if (printer->orientation() == QPrinter::Portrait) |
|
359 cols = qCeil(qSqrt((float) numPages)); |
|
360 else |
|
361 cols = qFloor(qSqrt((float) numPages)); |
|
362 cols += cols % 2; // Nicer with an even number of cols |
|
363 } |
|
364 else if (viewMode == QPrintPreviewWidget::FacingPagesView) { |
|
365 cols = 2; |
|
366 numPagePlaces += 1; |
|
367 } |
|
368 int rows = qCeil(qreal(numPagePlaces) / cols); |
|
369 |
|
370 qreal itemWidth = pages.at(0)->boundingRect().width(); |
|
371 qreal itemHeight = pages.at(0)->boundingRect().height(); |
|
372 int pageNum = 1; |
|
373 for (int i = 0; i < rows && pageNum <= numPages; i++) { |
|
374 for (int j = 0; j < cols && pageNum <= numPages; j++) { |
|
375 if (!i && !j && viewMode == QPrintPreviewWidget::FacingPagesView) { |
|
376 // Front page doesn't have a facing page |
|
377 continue; |
|
378 } else { |
|
379 pages.at(pageNum-1)->setPos(QPointF(j*itemWidth, i*itemHeight)); |
|
380 pageNum++; |
|
381 } |
|
382 } |
|
383 } |
|
384 scene->setSceneRect(scene->itemsBoundingRect()); |
|
385 } |
|
386 |
|
387 void QPrintPreviewWidgetPrivate::generatePreview() |
|
388 { |
|
389 //### If QPrinter::setPreviewMode() becomes public, handle the |
|
390 //### case that we have been constructed with a printer that |
|
391 //### _already_ has been preview-painted to, so we should |
|
392 //### initially just show the pages it already contains, and not |
|
393 //### emit paintRequested() until the user changes some parameter |
|
394 |
|
395 Q_Q(QPrintPreviewWidget); |
|
396 printer->d_func()->setPreviewMode(true); |
|
397 emit q->paintRequested(printer); |
|
398 printer->d_func()->setPreviewMode(false); |
|
399 pictures = printer->d_func()->previewPages(); |
|
400 populateScene(); // i.e. setPreviewPrintedPictures() e.l. |
|
401 layoutPages(); |
|
402 curPage = qBound(1, curPage, pages.count()); |
|
403 if (fitting) |
|
404 _q_fit(); |
|
405 emit q->previewChanged(); |
|
406 } |
|
407 |
|
408 void QPrintPreviewWidgetPrivate::setCurrentPage(int pageNumber) |
|
409 { |
|
410 if (pageNumber < 1 || pageNumber > pages.count()) |
|
411 return; |
|
412 |
|
413 int lastPage = curPage; |
|
414 curPage = pageNumber; |
|
415 |
|
416 if (lastPage != curPage && lastPage > 0 && lastPage <= pages.count()) { |
|
417 if (zoomMode != QPrintPreviewWidget::FitInView) { |
|
418 QScrollBar *hsc = graphicsView->horizontalScrollBar(); |
|
419 QScrollBar *vsc = graphicsView->verticalScrollBar(); |
|
420 QPointF pt = graphicsView->transform().map(pages.at(curPage-1)->pos()); |
|
421 vsc->setValue(int(pt.y()) - 10); |
|
422 hsc->setValue(int(pt.x()) - 10); |
|
423 } else { |
|
424 graphicsView->centerOn(pages.at(curPage-1)); |
|
425 } |
|
426 } |
|
427 } |
|
428 |
|
429 void QPrintPreviewWidgetPrivate::zoom(qreal zoom) |
|
430 { |
|
431 zoomFactor *= zoom; |
|
432 graphicsView->scale(zoom, zoom); |
|
433 } |
|
434 |
|
435 void QPrintPreviewWidgetPrivate::setZoomFactor(qreal _zoomFactor) |
|
436 { |
|
437 Q_Q(QPrintPreviewWidget); |
|
438 zoomFactor = _zoomFactor; |
|
439 graphicsView->resetTransform(); |
|
440 int dpi_y = q->logicalDpiY(); |
|
441 int printer_dpi_y = printer->logicalDpiY(); |
|
442 graphicsView->scale(zoomFactor*(dpi_y/float(printer_dpi_y)), |
|
443 zoomFactor*(dpi_y/float(printer_dpi_y))); |
|
444 } |
|
445 |
|
446 /////////////////////////////////////// |
|
447 |
|
448 /*! |
|
449 \class QPrintPreviewWidget |
|
450 \since 4.4 |
|
451 |
|
452 \brief The QPrintPreviewWidget class provides a widget for |
|
453 previewing page layouts for printer output. |
|
454 |
|
455 \ingroup printing |
|
456 |
|
457 QPrintPreviewDialog uses a QPrintPreviewWidget internally, and the |
|
458 purpose of QPrintPreviewWidget is to make it possible to embed the |
|
459 preview into other widgets. It also makes it possible to build a different |
|
460 user interface around it than the default one provided with QPrintPreviewDialog. |
|
461 |
|
462 Using QPrintPreviewWidget is straightforward: |
|
463 |
|
464 \list 1 |
|
465 \o Create the QPrintPreviewWidget |
|
466 |
|
467 Construct the QPrintPreviewWidget either by passing in an |
|
468 exisiting QPrinter object, or have QPrintPreviewWidget create a |
|
469 default constructed QPrinter object for you. |
|
470 |
|
471 \o Connect the paintRequested() signal to a slot. |
|
472 |
|
473 When the widget needs to generate a set of preview pages, a |
|
474 paintRequested() signal will be emitted from the widget. Connect a |
|
475 slot to this signal, and draw onto the QPrinter passed in as a |
|
476 signal parameter. Call QPrinter::newPage(), to start a new |
|
477 page in the preview. |
|
478 |
|
479 \endlist |
|
480 |
|
481 \sa QPrinter, QPrintDialog, QPageSetupDialog, QPrintPreviewDialog |
|
482 */ |
|
483 |
|
484 |
|
485 /*! |
|
486 \enum QPrintPreviewWidget::ViewMode |
|
487 |
|
488 This enum is used to describe the view mode of the preview widget. |
|
489 |
|
490 \value SinglePageView A mode where single pages in the preview |
|
491 is viewed. |
|
492 |
|
493 \value FacingPagesView A mode where the facing pages in the preview |
|
494 is viewed. |
|
495 |
|
496 \value AllPagesView A view mode where all the pages in the preview |
|
497 is viewed. |
|
498 */ |
|
499 |
|
500 /*! |
|
501 \enum QPrintPreviewWidget::ZoomMode |
|
502 |
|
503 This enum is used to describe zoom mode of the preview widget. |
|
504 |
|
505 \value CustomZoom The zoom is set to a custom zoom value. |
|
506 |
|
507 \value FitToWidth This mode fits the current page to the width of the view. |
|
508 |
|
509 \value FitInView This mode fits the current page inside the view. |
|
510 |
|
511 */ |
|
512 |
|
513 /*! |
|
514 Constructs a QPrintPreviewWidget based on \a printer and with \a |
|
515 parent as the parent widget. The widget flags \a flags are passed on |
|
516 to the QWidget constructor. |
|
517 |
|
518 \sa QWidget::setWindowFlags() |
|
519 */ |
|
520 QPrintPreviewWidget::QPrintPreviewWidget(QPrinter *printer, QWidget *parent, Qt::WindowFlags flags) |
|
521 : QWidget(*new QPrintPreviewWidgetPrivate, parent, flags) |
|
522 { |
|
523 Q_D(QPrintPreviewWidget); |
|
524 d->printer = printer; |
|
525 d->ownPrinter = false; |
|
526 d->init(); |
|
527 } |
|
528 |
|
529 /*! |
|
530 \overload |
|
531 |
|
532 This will cause QPrintPreviewWidget to create an internal, default |
|
533 constructed QPrinter object, which will be used to generate the |
|
534 preview. |
|
535 */ |
|
536 QPrintPreviewWidget::QPrintPreviewWidget(QWidget *parent, Qt::WindowFlags flags) |
|
537 : QWidget(*new QPrintPreviewWidgetPrivate, parent, flags) |
|
538 { |
|
539 Q_D(QPrintPreviewWidget); |
|
540 d->printer = new QPrinter; |
|
541 d->ownPrinter = true; |
|
542 d->init(); |
|
543 } |
|
544 |
|
545 |
|
546 /*! |
|
547 Destroys the QPrintPreviewWidget. |
|
548 */ |
|
549 QPrintPreviewWidget::~QPrintPreviewWidget() |
|
550 { |
|
551 Q_D(QPrintPreviewWidget); |
|
552 if (d->ownPrinter) |
|
553 delete d->printer; |
|
554 } |
|
555 |
|
556 /*! |
|
557 Returns the current view mode. The default view mode is SinglePageView. |
|
558 */ |
|
559 QPrintPreviewWidget::ViewMode QPrintPreviewWidget::viewMode() const |
|
560 { |
|
561 Q_D(const QPrintPreviewWidget); |
|
562 return d->viewMode; |
|
563 } |
|
564 |
|
565 /*! |
|
566 Sets the view mode to \a mode. The default view mode is |
|
567 SinglePageView. |
|
568 */ |
|
569 void QPrintPreviewWidget::setViewMode(ViewMode mode) |
|
570 { |
|
571 Q_D(QPrintPreviewWidget); |
|
572 d->viewMode = mode; |
|
573 d->layoutPages(); |
|
574 if (d->viewMode == AllPagesView) { |
|
575 d->graphicsView->fitInView(d->scene->itemsBoundingRect(), Qt::KeepAspectRatio); |
|
576 d->fitting = false; |
|
577 d->zoomMode = QPrintPreviewWidget::CustomZoom; |
|
578 d->zoomFactor = d->graphicsView->transform().m11() * (float(d->printer->logicalDpiY()) / logicalDpiY()); |
|
579 emit previewChanged(); |
|
580 } else { |
|
581 d->fitting = true; |
|
582 d->_q_fit(); |
|
583 } |
|
584 } |
|
585 |
|
586 /*! |
|
587 Returns the current orientation of the preview. This value is |
|
588 obtained from the QPrinter object associated with the preview. |
|
589 */ |
|
590 QPrinter::Orientation QPrintPreviewWidget::orientation() const |
|
591 { |
|
592 Q_D(const QPrintPreviewWidget); |
|
593 return d->printer->orientation(); |
|
594 } |
|
595 |
|
596 /*! |
|
597 Sets the current orientation to \a orientation. This value will be |
|
598 set on the QPrinter object associated with the preview. |
|
599 */ |
|
600 void QPrintPreviewWidget::setOrientation(QPrinter::Orientation orientation) |
|
601 { |
|
602 Q_D(QPrintPreviewWidget); |
|
603 d->printer->setOrientation(orientation); |
|
604 d->generatePreview(); |
|
605 } |
|
606 |
|
607 /*! |
|
608 Prints the preview to the printer associated with the preview. |
|
609 */ |
|
610 void QPrintPreviewWidget::print() |
|
611 { |
|
612 Q_D(QPrintPreviewWidget); |
|
613 // ### make use of the generated pages |
|
614 emit paintRequested(d->printer); |
|
615 } |
|
616 |
|
617 /*! |
|
618 Zooms the current view in by \a factor. The default value for \a |
|
619 factor is 1.1, which means the view will be scaled up by 10%. |
|
620 */ |
|
621 void QPrintPreviewWidget::zoomIn(qreal factor) |
|
622 { |
|
623 Q_D(QPrintPreviewWidget); |
|
624 d->fitting = false; |
|
625 d->zoomMode = QPrintPreviewWidget::CustomZoom; |
|
626 d->zoom(factor); |
|
627 } |
|
628 |
|
629 /*! |
|
630 Zooms the current view out by \a factor. The default value for \a |
|
631 factor is 1.1, which means the view will be scaled down by 10%. |
|
632 */ |
|
633 void QPrintPreviewWidget::zoomOut(qreal factor) |
|
634 { |
|
635 Q_D(QPrintPreviewWidget); |
|
636 d->fitting = false; |
|
637 d->zoomMode = QPrintPreviewWidget::CustomZoom; |
|
638 d->zoom(1/factor); |
|
639 } |
|
640 |
|
641 /*! |
|
642 Returns the zoom factor of the view. |
|
643 */ |
|
644 qreal QPrintPreviewWidget::zoomFactor() const |
|
645 { |
|
646 Q_D(const QPrintPreviewWidget); |
|
647 return d->zoomFactor; |
|
648 } |
|
649 |
|
650 /*! |
|
651 Sets the zoom factor of the view to \a factor. For example, a |
|
652 value of 1.0 indicates an unscaled view, which is approximately |
|
653 the size the view will have on paper. A value of 0.5 will halve |
|
654 the size of the view, while a value of 2.0 will double the size of |
|
655 the view. |
|
656 */ |
|
657 void QPrintPreviewWidget::setZoomFactor(qreal factor) |
|
658 { |
|
659 Q_D(QPrintPreviewWidget); |
|
660 d->fitting = false; |
|
661 d->zoomMode = QPrintPreviewWidget::CustomZoom; |
|
662 d->setZoomFactor(factor); |
|
663 } |
|
664 |
|
665 /*! |
|
666 Returns the number of pages in the preview. |
|
667 */ |
|
668 int QPrintPreviewWidget::numPages() const |
|
669 { |
|
670 Q_D(const QPrintPreviewWidget); |
|
671 return d->pages.size(); |
|
672 } |
|
673 |
|
674 /*! |
|
675 Returns the currently viewed page in the preview. |
|
676 */ |
|
677 int QPrintPreviewWidget::currentPage() const |
|
678 { |
|
679 Q_D(const QPrintPreviewWidget); |
|
680 return d->curPage; |
|
681 } |
|
682 |
|
683 /*! |
|
684 Sets the current page in the preview. This will cause the view to |
|
685 skip to the beginning of \a page. |
|
686 */ |
|
687 void QPrintPreviewWidget::setCurrentPage(int page) |
|
688 { |
|
689 Q_D(QPrintPreviewWidget); |
|
690 d->setCurrentPage(page); |
|
691 } |
|
692 |
|
693 /*! |
|
694 This is a convenience function and is the same as calling \c |
|
695 {setZoomMode(QPrintPreviewWidget::FitToWidth)}. |
|
696 */ |
|
697 void QPrintPreviewWidget::fitToWidth() |
|
698 { |
|
699 setZoomMode(FitToWidth); |
|
700 } |
|
701 |
|
702 /*! |
|
703 This is a convenience function and is the same as calling \c |
|
704 {setZoomMode(QPrintPreviewWidget::FitInView)}. |
|
705 */ |
|
706 void QPrintPreviewWidget::fitInView() |
|
707 { |
|
708 setZoomMode(FitInView); |
|
709 } |
|
710 |
|
711 /*! |
|
712 Sets the zoom mode to \a zoomMode. The default zoom mode is FitInView. |
|
713 |
|
714 \sa zoomMode(), viewMode(), setViewMode() |
|
715 */ |
|
716 void QPrintPreviewWidget::setZoomMode(QPrintPreviewWidget::ZoomMode zoomMode) |
|
717 { |
|
718 Q_D(QPrintPreviewWidget); |
|
719 d->zoomMode = zoomMode; |
|
720 if (d->zoomMode == FitInView || d->zoomMode == FitToWidth) { |
|
721 d->fitting = true; |
|
722 d->_q_fit(true); |
|
723 } else { |
|
724 d->fitting = false; |
|
725 } |
|
726 } |
|
727 |
|
728 /*! |
|
729 Returns the current zoom mode. |
|
730 |
|
731 \sa setZoomMode(), viewMode(), setViewMode() |
|
732 */ |
|
733 QPrintPreviewWidget::ZoomMode QPrintPreviewWidget::zoomMode() const |
|
734 { |
|
735 Q_D(const QPrintPreviewWidget); |
|
736 return d->zoomMode; |
|
737 } |
|
738 |
|
739 /*! |
|
740 This is a convenience function and is the same as calling \c |
|
741 {setOrientation(QPrinter::Landscape)}. |
|
742 */ |
|
743 void QPrintPreviewWidget::setLandscapeOrientation() |
|
744 { |
|
745 setOrientation(QPrinter::Landscape); |
|
746 } |
|
747 |
|
748 /*! |
|
749 This is a convenience function and is the same as calling \c |
|
750 {setOrientation(QPrinter::Portrait)}. |
|
751 */ |
|
752 void QPrintPreviewWidget::setPortraitOrientation() |
|
753 { |
|
754 setOrientation(QPrinter::Portrait); |
|
755 } |
|
756 |
|
757 /*! |
|
758 This is a convenience function and is the same as calling \c |
|
759 {setViewMode(QPrintPreviewWidget::SinglePageView)}. |
|
760 */ |
|
761 void QPrintPreviewWidget::setSinglePageViewMode() |
|
762 { |
|
763 setViewMode(SinglePageView); |
|
764 } |
|
765 |
|
766 /*! |
|
767 This is a convenience function and is the same as calling \c |
|
768 {setViewMode(QPrintPreviewWidget::FacingPagesView)}. |
|
769 */ |
|
770 void QPrintPreviewWidget::setFacingPagesViewMode() |
|
771 { |
|
772 setViewMode(FacingPagesView); |
|
773 } |
|
774 |
|
775 /*! |
|
776 This is a convenience function and is the same as calling \c |
|
777 {setViewMode(QPrintPreviewWidget::AllPagesView)}. |
|
778 */ |
|
779 void QPrintPreviewWidget::setAllPagesViewMode() |
|
780 { |
|
781 setViewMode(AllPagesView); |
|
782 } |
|
783 |
|
784 |
|
785 /*! |
|
786 This function updates the preview, which causes the |
|
787 paintRequested() signal to be emitted. |
|
788 */ |
|
789 void QPrintPreviewWidget::updatePreview() |
|
790 { |
|
791 Q_D(QPrintPreviewWidget); |
|
792 d->initialized = true; |
|
793 d->generatePreview(); |
|
794 d->graphicsView->updateGeometry(); |
|
795 } |
|
796 |
|
797 /*! \reimp |
|
798 */ |
|
799 void QPrintPreviewWidget::setVisible(bool visible) |
|
800 { |
|
801 Q_D(QPrintPreviewWidget); |
|
802 if (visible && !d->initialized) |
|
803 updatePreview(); |
|
804 QWidget::setVisible(visible); |
|
805 } |
|
806 |
|
807 /*! |
|
808 \fn void QPrintPreviewWidget::paintRequested(QPrinter *printer) |
|
809 |
|
810 This signal is emitted when the preview widget needs to generate a |
|
811 set of preview pages. \a printer is the printer associated with |
|
812 this preview widget. |
|
813 */ |
|
814 |
|
815 /*! |
|
816 \fn void QPrintPreviewWidget::previewChanged() |
|
817 |
|
818 This signal is emitted whenever the preview widget has changed |
|
819 some internal state, such as the orientation. |
|
820 */ |
|
821 |
|
822 |
|
823 QT_END_NAMESPACE |
|
824 |
|
825 #include "moc_qprintpreviewwidget.cpp" |
|
826 #include "qprintpreviewwidget.moc" |
|
827 |
|
828 #endif // QT_NO_PRINTPREVIEWWIDGET |