https://bugs.webkit.org/show_bug.cgi?id=51328
[WebKit-https.git] / 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 using namespace WebCore;
32
33 namespace WebCore {
34
35 PrintContext::PrintContext(Frame* frame)
36     : m_frame(frame)
37     , m_isPrinting(false)
38 {
39 }
40
41 PrintContext::~PrintContext()
42 {
43     if (m_isPrinting)
44         end();
45     m_pageRects.clear();
46 }
47
48 int PrintContext::pageCount() const
49 {
50     return m_pageRects.size();
51 }
52
53 const IntRect& PrintContext::pageRect(int pageNumber) const
54 {
55     return m_pageRects[pageNumber];
56 }
57
58 void PrintContext::computePageRects(const FloatRect& printRect, float headerHeight, float footerHeight, float userScaleFactor, float& outPageHeight)
59 {
60     m_pageRects.clear();
61     outPageHeight = 0;
62
63     if (!m_frame->document() || !m_frame->view() || !m_frame->document()->renderer())
64         return;
65
66     if (userScaleFactor <= 0) {
67         LOG_ERROR("userScaleFactor has bad value %.2f", userScaleFactor);
68         return;
69     }
70
71     RenderView* view = toRenderView(m_frame->document()->renderer());
72
73     float ratio = printRect.height() / printRect.width();
74
75     float pageWidth  = view->docWidth();
76     float pageHeight = pageWidth * ratio;
77     outPageHeight = pageHeight; // this is the height of the page adjusted by margins
78     pageHeight -= headerHeight + footerHeight;
79
80     if (pageHeight <= 0) {
81         LOG_ERROR("pageHeight has bad value %.2f", pageHeight);
82         return;
83     }
84
85     computePageRectsWithPageSizeInternal(FloatSize(pageWidth / userScaleFactor, pageHeight / userScaleFactor), false);
86 }
87
88 void PrintContext::computePageRectsWithPageSize(const FloatSize& pageSizeInPixels, bool allowHorizontalMultiPages)
89 {
90     m_pageRects.clear();
91     computePageRectsWithPageSizeInternal(pageSizeInPixels, allowHorizontalMultiPages);
92 }
93
94 void PrintContext::computePageRectsWithPageSizeInternal(const FloatSize& pageSizeInPixels, bool allowHorizontalMultiPages)
95 {
96     if (!m_frame->document() || !m_frame->view() || !m_frame->document()->renderer())
97         return;
98
99     RenderView* view = toRenderView(m_frame->document()->renderer());
100
101     IntRect docRect = view->documentRect();
102
103     int pageWidth = pageSizeInPixels.width();
104     int pageHeight = pageSizeInPixels.height();
105
106     unsigned pageCount = ceilf((float)docRect.height() / pageHeight);
107     for (unsigned i = 0; i < pageCount; ++i) {
108         if (allowHorizontalMultiPages) {
109             for (int currentX = docRect.x(); currentX < docRect.right(); currentX += pageWidth)
110                 m_pageRects.append(IntRect(currentX, docRect.y() + i * pageHeight, pageWidth, pageHeight));
111         } else
112             m_pageRects.append(IntRect(docRect.x(), docRect.y() + i * pageHeight, pageWidth, pageHeight));
113     }
114 }
115
116 void PrintContext::begin(float width, float height)
117 {
118     ASSERT(!m_isPrinting);
119     m_isPrinting = true;
120
121     // By imaging to a width a little wider than the available pixels,
122     // thin pages will be scaled down a little, matching the way they
123     // print in IE and Camino. This lets them use fewer sheets than they
124     // would otherwise, which is presumably why other browsers do this.
125     // Wide pages will be scaled down more than this.
126     const float PrintingMinimumShrinkFactor = 1.25f;
127
128     // This number determines how small we are willing to reduce the page content
129     // in order to accommodate the widest line. If the page would have to be
130     // reduced smaller to make the widest line fit, we just clip instead (this
131     // behavior matches MacIE and Mozilla, at least)
132     const float PrintingMaximumShrinkFactor = 2.0f;
133
134     float minLayoutWidth = width * PrintingMinimumShrinkFactor;
135     float minLayoutHeight = height * PrintingMinimumShrinkFactor;
136
137     // FIXME: This will modify the rendering of the on-screen frame.
138     // Could lead to flicker during printing.
139     m_frame->setPrinting(true, FloatSize(minLayoutWidth, minLayoutHeight), PrintingMaximumShrinkFactor / PrintingMinimumShrinkFactor, Frame::AdjustViewSize);
140 }
141
142 void PrintContext::spoolPage(GraphicsContext& ctx, int pageNumber, float width)
143 {
144     IntRect pageRect = m_pageRects[pageNumber];
145     float scale = width / pageRect.width();
146
147     ctx.save();
148     ctx.scale(FloatSize(scale, scale));
149     ctx.translate(-pageRect.x(), -pageRect.y());
150     ctx.clip(pageRect);
151     m_frame->view()->paintContents(&ctx, pageRect);
152     ctx.restore();
153 }
154
155 void PrintContext::end()
156 {
157     ASSERT(m_isPrinting);
158     m_isPrinting = false;
159     m_frame->setPrinting(false, FloatSize(), 0, Frame::AdjustViewSize);
160 }
161
162 static RenderBoxModelObject* enclosingBoxModelObject(RenderObject* object)
163 {
164
165     while (object && !object->isBoxModelObject())
166         object = object->parent();
167     if (!object)
168         return 0;
169     return toRenderBoxModelObject(object);
170 }
171
172 int PrintContext::pageNumberForElement(Element* element, const FloatSize& pageSizeInPixels)
173 {
174     // Make sure the element is not freed during the layout.
175     RefPtr<Element> elementRef(element);
176     element->document()->updateLayout();
177
178     RenderBoxModelObject* box = enclosingBoxModelObject(element->renderer());
179     if (!box)
180         return -1;
181
182     Frame* frame = element->document()->frame();
183     FloatRect pageRect(FloatPoint(0, 0), pageSizeInPixels);
184     PrintContext printContext(frame);
185     printContext.begin(pageRect.width(), pageRect.height());
186     FloatSize scaledPageSize = pageSizeInPixels;
187     scaledPageSize.scale(frame->view()->contentsSize().width() / pageRect.width());
188     printContext.computePageRectsWithPageSize(scaledPageSize, false);
189
190     int top = box->offsetTop();
191     int left = box->offsetLeft();
192     int pageNumber = 0;
193     for (; pageNumber < printContext.pageCount(); pageNumber++) {
194         const IntRect& page = printContext.pageRect(pageNumber);
195         if (page.x() <= left && left < page.right() && page.y() <= top && top < page.bottom())
196             return pageNumber;
197     }
198     return -1;
199 }
200
201 String PrintContext::pageProperty(Frame* frame, const char* propertyName, int pageNumber)
202 {
203     Document* document = frame->document();
204     PrintContext printContext(frame);
205     printContext.begin(800); // Any width is OK here.
206     document->updateLayout();
207     RefPtr<RenderStyle> style = document->styleForPage(pageNumber);
208
209     // Implement formatters for properties we care about.
210     if (!strcmp(propertyName, "margin-left")) {
211         if (style->marginLeft().isAuto())
212             return String("auto");
213         return String::number(style->marginLeft().rawValue());
214     }
215     if (!strcmp(propertyName, "line-height"))
216         return String::number(style->lineHeight().rawValue());
217     if (!strcmp(propertyName, "font-size"))
218         return String::number(style->fontDescription().computedPixelSize());
219     if (!strcmp(propertyName, "font-family"))
220         return style->fontDescription().family().family().string();
221     if (!strcmp(propertyName, "size"))
222         return makeString(String::number(style->pageSize().width().rawValue()), ' ', String::number(style->pageSize().height().rawValue()));
223
224     return makeString("pageProperty() unimplemented for: ", propertyName);
225 }
226
227 bool PrintContext::isPageBoxVisible(Frame* frame, int pageNumber)
228 {
229     return frame->document()->isPageBoxVisible(pageNumber);
230 }
231
232 String PrintContext::pageSizeAndMarginsInPixels(Frame* frame, int pageNumber, int width, int height, int marginTop, int marginRight, int marginBottom, int marginLeft)
233 {
234     IntSize pageSize(width, height);
235     frame->document()->pageSizeAndMarginsInPixels(pageNumber, pageSize, marginTop, marginRight, marginBottom, marginLeft);
236
237     // We don't have a makeString() function that takes up to 12 arguments, if this is a hot function, we can provide one.
238     return makeString('(', String::number(pageSize.width()), ", ", String::number(pageSize.height()), ") ") +
239            makeString(String::number(marginTop), ' ', String::number(marginRight), ' ', String::number(marginBottom), ' ', String::number(marginLeft));
240 }
241
242 int PrintContext::numberOfPages(Frame* frame, const FloatSize& pageSizeInPixels)
243 {
244     frame->document()->updateLayout();
245
246     FloatRect pageRect(FloatPoint(0, 0), pageSizeInPixels);
247     PrintContext printContext(frame);
248     printContext.begin(pageRect.width(), pageRect.height());
249     // Account for shrink-to-fit.
250     FloatSize scaledPageSize = pageSizeInPixels;
251     scaledPageSize.scale(frame->view()->contentsSize().width() / pageRect.width());
252     printContext.computePageRectsWithPageSize(scaledPageSize, false);
253     return printContext.pageCount();
254 }
255
256 void PrintContext::spoolAllPagesWithBoundaries(Frame* frame, GraphicsContext& graphicsContext, const FloatSize& pageSizeInPixels)
257 {
258     if (!frame->document() || !frame->view() || !frame->document()->renderer())
259         return;
260
261     frame->document()->updateLayout();
262
263     PrintContext printContext(frame);
264     printContext.begin(pageSizeInPixels.width(), pageSizeInPixels.height());
265
266     float pageHeight;
267     printContext.computePageRects(FloatRect(FloatPoint(0, 0), pageSizeInPixels), 0, 0, 1, pageHeight);
268
269     const float pageWidth = pageSizeInPixels.width();
270     const Vector<IntRect>& pageRects = printContext.pageRects();
271     int totalHeight = pageRects.size() * (pageSizeInPixels.height() + 1) - 1;
272
273     // Fill the whole background by white.
274     graphicsContext.setFillColor(Color(255, 255, 255), ColorSpaceDeviceRGB);
275     graphicsContext.fillRect(FloatRect(0, 0, pageWidth, totalHeight));
276
277     graphicsContext.save();
278     graphicsContext.translate(0, totalHeight);
279     graphicsContext.scale(FloatSize(1, -1));
280
281     int currentHeight = 0;
282     for (size_t pageIndex = 0; pageIndex < pageRects.size(); pageIndex++) {
283         // Draw a line for a page boundary if this isn't the first page.
284         if (pageIndex > 0) {
285             graphicsContext.save();
286             graphicsContext.setStrokeColor(Color(0, 0, 255), ColorSpaceDeviceRGB);
287             graphicsContext.setFillColor(Color(0, 0, 255), ColorSpaceDeviceRGB);
288             graphicsContext.drawLine(IntPoint(0, currentHeight),
289                                      IntPoint(pageWidth, currentHeight));
290             graphicsContext.restore();
291         }
292
293         graphicsContext.save();
294         graphicsContext.translate(0, currentHeight);
295         printContext.spoolPage(graphicsContext, pageIndex, pageWidth);
296         graphicsContext.restore();
297
298         currentHeight += pageSizeInPixels.height() + 1;
299     }
300
301     graphicsContext.restore();
302 }
303
304 }