https://bugs.webkit.org/show_bug.cgi?id=46422, make printing and pagination work
[WebKit-https.git] / Source / WebCore / page / PrintContext.cpp
1 /*
2  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
3  * Copyright (C) 2007 Apple Inc.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Library General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Library General Public License for more details.
14  *
15  * You should have received a copy of the GNU Library General Public License
16  * along with this library; see the file COPYING.LIB.  If not, write to
17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  * Boston, MA 02110-1301, USA.
19  */
20
21 #include "config.h"
22 #include "PrintContext.h"
23
24 #include "GraphicsContext.h"
25 #include "Frame.h"
26 #include "FrameView.h"
27 #include "RenderLayer.h"
28 #include "RenderView.h"
29 #include <wtf/text/StringConcatenate.h>
30
31 namespace WebCore {
32
33 // By imaging to a width a little wider than the available pixels,
34 // thin pages will be scaled down a little, matching the way they
35 // print in IE and Camino. This lets them use fewer sheets than they
36 // would otherwise, which is presumably why other browsers do this.
37 // Wide pages will be scaled down more than this.
38 const float printingMinimumShrinkFactor = 1.25f;
39
40 // This number determines how small we are willing to reduce the page content
41 // in order to accommodate the widest line. If the page would have to be
42 // reduced smaller to make the widest line fit, we just clip instead (this
43 // behavior matches MacIE and Mozilla, at least)
44 const float printingMaximumShrinkFactor = 2;
45
46 PrintContext::PrintContext(Frame* frame)
47     : m_frame(frame)
48     , m_isPrinting(false)
49 {
50 }
51
52 PrintContext::~PrintContext()
53 {
54     if (m_isPrinting)
55         end();
56 }
57
58 size_t PrintContext::pageCount() const
59 {
60     return m_pageRects.size();
61 }
62
63 const IntRect& PrintContext::pageRect(size_t pageNumber) const
64 {
65     return m_pageRects[pageNumber];
66 }
67
68 void PrintContext::computePageRects(const FloatRect& printRect, float headerHeight, float footerHeight, float userScaleFactor, float& outPageHeight, bool allowHorizontalTiling)
69 {
70     m_pageRects.clear();
71     outPageHeight = 0;
72
73     if (!m_frame->document() || !m_frame->view() || !m_frame->document()->renderer())
74         return;
75
76     if (userScaleFactor <= 0) {
77         LOG_ERROR("userScaleFactor has bad value %.2f", userScaleFactor);
78         return;
79     }
80
81     RenderView* view = toRenderView(m_frame->document()->renderer());
82
83     bool isHorizontal = view->style()->isHorizontalWritingMode();
84
85     float pageWidth;
86     float pageHeight;
87     if (isHorizontal) {
88         float ratio = printRect.height() / printRect.width();
89         pageWidth = view->docWidth();
90         pageHeight = floorf(pageWidth * ratio);
91     } else {
92         float ratio = printRect.width() / printRect.height();
93         pageHeight = view->docHeight();
94         pageWidth = floorf(pageHeight * ratio);
95     }
96
97     outPageHeight = pageHeight; // this is the height of the page adjusted by margins
98     pageHeight -= headerHeight + footerHeight;
99
100     if (pageHeight <= 0) {
101         LOG_ERROR("pageHeight has bad value %.2f", pageHeight);
102         return;
103     }
104
105     computePageRectsWithPageSizeInternal(FloatSize(pageWidth / userScaleFactor, pageHeight / userScaleFactor), allowHorizontalTiling);
106 }
107
108 void PrintContext::computePageRectsWithPageSize(const FloatSize& pageSizeInPixels, bool allowHorizontalTiling)
109 {
110     m_pageRects.clear();
111     computePageRectsWithPageSizeInternal(pageSizeInPixels, allowHorizontalTiling);
112 }
113
114 void PrintContext::computePageRectsWithPageSizeInternal(const FloatSize& pageSizeInPixels, bool allowInlineDirectionTiling)
115 {
116     if (!m_frame->document() || !m_frame->view() || !m_frame->document()->renderer())
117         return;
118
119     RenderView* view = toRenderView(m_frame->document()->renderer());
120
121     IntRect docRect = view->documentRect();
122
123     int pageWidth = pageSizeInPixels.width();
124     int pageHeight = pageSizeInPixels.height();
125
126     bool isHorizontal = view->style()->isHorizontalWritingMode();
127
128     int docLogicalHeight = isHorizontal ? docRect.height() : docRect.width();
129     int pageLogicalHeight = isHorizontal ? pageHeight : pageWidth;
130     int pageLogicalWidth = isHorizontal ? pageWidth : pageHeight;
131
132     int inlineDirectionStart;
133     int inlineDirectionEnd;
134     int blockDirectionStart;
135     int blockDirectionEnd;
136     if (isHorizontal) {
137         if (view->style()->isFlippedBlocksWritingMode()) {
138             blockDirectionStart = docRect.bottom();
139             blockDirectionEnd = docRect.y();
140         } else {
141             blockDirectionStart = docRect.y();
142             blockDirectionEnd = docRect.bottom();
143         }
144         inlineDirectionStart = view->style()->isLeftToRightDirection() ? docRect.x() : docRect.right();
145         inlineDirectionEnd = view->style()->isLeftToRightDirection() ? docRect.right() : docRect.x();
146     } else {
147         if (view->style()->isFlippedBlocksWritingMode()) {
148             blockDirectionStart = docRect.right();
149             blockDirectionEnd = docRect.x();
150         } else {
151             blockDirectionStart = docRect.x();
152             blockDirectionEnd = docRect.right();
153         }
154         inlineDirectionStart = view->style()->isLeftToRightDirection() ? docRect.y() : docRect.bottom();
155         inlineDirectionEnd = view->style()->isLeftToRightDirection() ? docRect.bottom() : docRect.y();
156     }
157
158     unsigned pageCount = ceilf((float)docLogicalHeight / pageLogicalHeight);
159     for (unsigned i = 0; i < pageCount; ++i) {
160         int pageLogicalTop = blockDirectionEnd > blockDirectionStart ?
161                                 blockDirectionStart + i * pageLogicalHeight : 
162                                 blockDirectionStart - (i + 1) * pageLogicalHeight;
163         if (allowInlineDirectionTiling) {
164             for (int currentInlinePosition = inlineDirectionStart;
165                  inlineDirectionEnd > inlineDirectionStart ? currentInlinePosition < inlineDirectionEnd : currentInlinePosition > inlineDirectionEnd;
166                  currentInlinePosition += (inlineDirectionEnd > inlineDirectionStart ? pageLogicalWidth : -pageLogicalWidth)) {
167                 int pageLogicalLeft = inlineDirectionEnd > inlineDirectionStart ? currentInlinePosition : currentInlinePosition - pageLogicalWidth;
168                 IntRect pageRect(pageLogicalLeft, pageLogicalTop, pageLogicalWidth, pageLogicalHeight);
169                 if (!isHorizontal)
170                     pageRect = pageRect.transposedRect();
171                 m_pageRects.append(pageRect);
172             }
173         } else {
174             int pageLogicalLeft = inlineDirectionEnd > inlineDirectionStart ? inlineDirectionStart : inlineDirectionStart - pageLogicalWidth;
175             IntRect pageRect(pageLogicalLeft, pageLogicalTop, pageLogicalWidth, pageLogicalHeight);
176             if (!isHorizontal)
177                 pageRect = pageRect.transposedRect();
178             m_pageRects.append(pageRect);
179         }
180     }
181 }
182
183 void PrintContext::begin(float width, float height)
184 {
185     // This function can be called multiple times to adjust printing parameters without going back to screen mode.
186     m_isPrinting = true;
187
188     float minLayoutWidth = width * printingMinimumShrinkFactor;
189     float minLayoutHeight = height * printingMinimumShrinkFactor;
190
191     // This changes layout, so callers need to make sure that they don't paint to screen while in printing mode.
192     m_frame->setPrinting(true, FloatSize(minLayoutWidth, minLayoutHeight), printingMaximumShrinkFactor / printingMinimumShrinkFactor, Frame::AdjustViewSize);
193 }
194
195 float PrintContext::computeAutomaticScaleFactor(const FloatSize& availablePaperSize)
196 {
197     if (!m_frame->view())
198         return 1;
199
200     bool useViewWidth = true;
201     if (m_frame->document() && m_frame->document()->renderView())
202         useViewWidth = m_frame->document()->renderView()->style()->isHorizontalWritingMode();
203
204     float viewLogicalWidth = useViewWidth ? m_frame->view()->contentsWidth() : m_frame->view()->contentsHeight();
205     if (viewLogicalWidth < 1)
206         return 1;
207
208     float maxShrinkToFitScaleFactor = 1 / printingMaximumShrinkFactor;
209     float shrinkToFitScaleFactor = (useViewWidth ? availablePaperSize.width() : availablePaperSize.height()) / viewLogicalWidth;
210     return max(maxShrinkToFitScaleFactor, shrinkToFitScaleFactor);
211 }
212
213 void PrintContext::spoolPage(GraphicsContext& ctx, int pageNumber, float width)
214 {
215     // FIXME: Not correct for vertical text.
216     IntRect pageRect = m_pageRects[pageNumber];
217     float scale = width / pageRect.width();
218
219     ctx.save();
220     ctx.scale(FloatSize(scale, scale));
221     ctx.translate(-pageRect.x(), -pageRect.y());
222     ctx.clip(pageRect);
223     m_frame->view()->paintContents(&ctx, pageRect);
224     ctx.restore();
225 }
226
227 void PrintContext::spoolRect(GraphicsContext& ctx, const IntRect& rect)
228 {
229     // FIXME: Not correct for vertical text.
230     ctx.save();
231     ctx.translate(-rect.x(), -rect.y());
232     ctx.clip(rect);
233     m_frame->view()->paintContents(&ctx, rect);
234     ctx.restore();
235 }
236
237 void PrintContext::end()
238 {
239     ASSERT(m_isPrinting);
240     m_isPrinting = false;
241     m_frame->setPrinting(false, FloatSize(), 0, Frame::AdjustViewSize);
242 }
243
244 static RenderBoxModelObject* enclosingBoxModelObject(RenderObject* object)
245 {
246
247     while (object && !object->isBoxModelObject())
248         object = object->parent();
249     if (!object)
250         return 0;
251     return toRenderBoxModelObject(object);
252 }
253
254 int PrintContext::pageNumberForElement(Element* element, const FloatSize& pageSizeInPixels)
255 {
256     // Make sure the element is not freed during the layout.
257     RefPtr<Element> elementRef(element);
258     element->document()->updateLayout();
259
260     RenderBoxModelObject* box = enclosingBoxModelObject(element->renderer());
261     if (!box)
262         return -1;
263
264     Frame* frame = element->document()->frame();
265     FloatRect pageRect(FloatPoint(0, 0), pageSizeInPixels);
266     PrintContext printContext(frame);
267     printContext.begin(pageRect.width(), pageRect.height());
268     FloatSize scaledPageSize = pageSizeInPixels;
269     scaledPageSize.scale(frame->view()->contentsSize().width() / pageRect.width());
270     printContext.computePageRectsWithPageSize(scaledPageSize, false);
271
272     int top = box->offsetTop();
273     int left = box->offsetLeft();
274     size_t pageNumber = 0;
275     for (; pageNumber < printContext.pageCount(); pageNumber++) {
276         const IntRect& page = printContext.pageRect(pageNumber);
277         if (page.x() <= left && left < page.right() && page.y() <= top && top < page.bottom())
278             return pageNumber;
279     }
280     return -1;
281 }
282
283 String PrintContext::pageProperty(Frame* frame, const char* propertyName, int pageNumber)
284 {
285     Document* document = frame->document();
286     PrintContext printContext(frame);
287     printContext.begin(800); // Any width is OK here.
288     document->updateLayout();
289     RefPtr<RenderStyle> style = document->styleForPage(pageNumber);
290
291     // Implement formatters for properties we care about.
292     if (!strcmp(propertyName, "margin-left")) {
293         if (style->marginLeft().isAuto())
294             return String("auto");
295         return String::number(style->marginLeft().rawValue());
296     }
297     if (!strcmp(propertyName, "line-height"))
298         return String::number(style->lineHeight().rawValue());
299     if (!strcmp(propertyName, "font-size"))
300         return String::number(style->fontDescription().computedPixelSize());
301     if (!strcmp(propertyName, "font-family"))
302         return style->fontDescription().family().family().string();
303     if (!strcmp(propertyName, "size"))
304         return makeString(String::number(style->pageSize().width().rawValue()), ' ', String::number(style->pageSize().height().rawValue()));
305
306     return makeString("pageProperty() unimplemented for: ", propertyName);
307 }
308
309 bool PrintContext::isPageBoxVisible(Frame* frame, int pageNumber)
310 {
311     return frame->document()->isPageBoxVisible(pageNumber);
312 }
313
314 String PrintContext::pageSizeAndMarginsInPixels(Frame* frame, int pageNumber, int width, int height, int marginTop, int marginRight, int marginBottom, int marginLeft)
315 {
316     IntSize pageSize(width, height);
317     frame->document()->pageSizeAndMarginsInPixels(pageNumber, pageSize, marginTop, marginRight, marginBottom, marginLeft);
318
319     // We don't have a makeString() function that takes up to 12 arguments, if this is a hot function, we can provide one.
320     return makeString('(', String::number(pageSize.width()), ", ", String::number(pageSize.height()), ") ") +
321            makeString(String::number(marginTop), ' ', String::number(marginRight), ' ', String::number(marginBottom), ' ', String::number(marginLeft));
322 }
323
324 int PrintContext::numberOfPages(Frame* frame, const FloatSize& pageSizeInPixels)
325 {
326     frame->document()->updateLayout();
327
328     FloatRect pageRect(FloatPoint(0, 0), pageSizeInPixels);
329     PrintContext printContext(frame);
330     printContext.begin(pageRect.width(), pageRect.height());
331     // Account for shrink-to-fit.
332     FloatSize scaledPageSize = pageSizeInPixels;
333     scaledPageSize.scale(frame->view()->contentsSize().width() / pageRect.width());
334     printContext.computePageRectsWithPageSize(scaledPageSize, false);
335     return printContext.pageCount();
336 }
337
338 void PrintContext::spoolAllPagesWithBoundaries(Frame* frame, GraphicsContext& graphicsContext, const FloatSize& pageSizeInPixels)
339 {
340     if (!frame->document() || !frame->view() || !frame->document()->renderer())
341         return;
342
343     frame->document()->updateLayout();
344
345     PrintContext printContext(frame);
346     printContext.begin(pageSizeInPixels.width(), pageSizeInPixels.height());
347
348     float pageHeight;
349     printContext.computePageRects(FloatRect(FloatPoint(0, 0), pageSizeInPixels), 0, 0, 1, pageHeight);
350
351     const float pageWidth = pageSizeInPixels.width();
352     const Vector<IntRect>& pageRects = printContext.pageRects();
353     int totalHeight = pageRects.size() * (pageSizeInPixels.height() + 1) - 1;
354
355     // Fill the whole background by white.
356     graphicsContext.setFillColor(Color(255, 255, 255), ColorSpaceDeviceRGB);
357     graphicsContext.fillRect(FloatRect(0, 0, pageWidth, totalHeight));
358
359     graphicsContext.save();
360     graphicsContext.translate(0, totalHeight);
361     graphicsContext.scale(FloatSize(1, -1));
362
363     int currentHeight = 0;
364     for (size_t pageIndex = 0; pageIndex < pageRects.size(); pageIndex++) {
365         // Draw a line for a page boundary if this isn't the first page.
366         if (pageIndex > 0) {
367             graphicsContext.save();
368             graphicsContext.setStrokeColor(Color(0, 0, 255), ColorSpaceDeviceRGB);
369             graphicsContext.setFillColor(Color(0, 0, 255), ColorSpaceDeviceRGB);
370             graphicsContext.drawLine(IntPoint(0, currentHeight),
371                                      IntPoint(pageWidth, currentHeight));
372             graphicsContext.restore();
373         }
374
375         graphicsContext.save();
376         graphicsContext.translate(0, currentHeight);
377         printContext.spoolPage(graphicsContext, pageIndex, pageWidth);
378         graphicsContext.restore();
379
380         currentHeight += pageSizeInPixels.height() + 1;
381     }
382
383     graphicsContext.restore();
384 }
385
386 }