2010-06-25 Yuzo Fujishima <yuzo@google.com>
[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
30 using namespace WebCore;
31
32 namespace WebCore {
33
34 PrintContext::PrintContext(Frame* frame)
35     : m_frame(frame)
36     , m_isPrinting(false)
37 {
38 }
39
40 PrintContext::~PrintContext()
41 {
42     if (m_isPrinting)
43         end();
44     m_pageRects.clear();
45 }
46
47 int PrintContext::pageCount() const
48 {
49     return m_pageRects.size();
50 }
51
52 const IntRect& PrintContext::pageRect(int pageNumber) const
53 {
54     return m_pageRects[pageNumber];
55 }
56
57 void PrintContext::computePageRects(const FloatRect& printRect, float headerHeight, float footerHeight, float userScaleFactor, float& outPageHeight)
58 {
59     m_pageRects.clear();
60     outPageHeight = 0;
61
62     if (!m_frame->document() || !m_frame->view() || !m_frame->document()->renderer())
63         return;
64
65     if (userScaleFactor <= 0) {
66         LOG_ERROR("userScaleFactor has bad value %.2f", userScaleFactor);
67         return;
68     }
69
70     RenderView* root = toRenderView(m_frame->document()->renderer());
71
72     float ratio = printRect.height() / printRect.width();
73
74     float pageWidth  = (float)root->rightLayoutOverflow();
75     float pageHeight = pageWidth * ratio;
76     outPageHeight = pageHeight; // this is the height of the page adjusted by margins
77     pageHeight -= headerHeight + footerHeight;
78
79     if (pageHeight <= 0) {
80         LOG_ERROR("pageHeight has bad value %.2f", pageHeight);
81         return;
82     }
83
84     computePageRectsWithPageSizeInternal(FloatSize(pageWidth / userScaleFactor, pageHeight / userScaleFactor), false);
85 }
86
87 void PrintContext::computePageRectsWithPageSize(const FloatSize& pageSizeInPixels, bool allowHorizontalMultiPages)
88 {
89     m_pageRects.clear();
90     computePageRectsWithPageSizeInternal(pageSizeInPixels, allowHorizontalMultiPages);
91 }
92
93 void PrintContext::computePageRectsWithPageSizeInternal(const FloatSize& pageSizeInPixels, bool allowHorizontalMultiPages)
94 {
95     if (!m_frame->document() || !m_frame->view() || !m_frame->document()->renderer())
96         return;
97     RenderView* root = toRenderView(m_frame->document()->renderer());
98
99     const float pageWidth = pageSizeInPixels.width();
100     const float docWidth = root->layer()->width();
101     const float docHeight = root->layer()->height();
102     float currPageHeight = pageSizeInPixels.height();
103
104     // always return at least one page, since empty files should print a blank page
105     float printedPagesHeight = 0;
106     do {
107         float proposedBottom = std::min(docHeight, printedPagesHeight + pageSizeInPixels.height());
108         m_frame->view()->adjustPageHeight(&proposedBottom, printedPagesHeight, proposedBottom, printedPagesHeight);
109         currPageHeight = max(1.0f, proposedBottom - printedPagesHeight);
110         if (allowHorizontalMultiPages) {
111             for (float curWidth = 0; curWidth < docWidth; curWidth += pageWidth)
112                 m_pageRects.append(IntRect(curWidth, (int)printedPagesHeight, (int)pageWidth, (int)currPageHeight));
113         } else
114             m_pageRects.append(IntRect(0, (int)printedPagesHeight, (int)pageWidth, (int)currPageHeight));
115         printedPagesHeight += currPageHeight;
116     } while (printedPagesHeight < docHeight);
117 }
118
119 void PrintContext::begin(float width)
120 {
121     ASSERT(!m_isPrinting);
122     m_isPrinting = true;
123
124     // By imaging to a width a little wider than the available pixels,
125     // thin pages will be scaled down a little, matching the way they
126     // print in IE and Camino. This lets them use fewer sheets than they
127     // would otherwise, which is presumably why other browsers do this.
128     // Wide pages will be scaled down more than this.
129     const float PrintingMinimumShrinkFactor = 1.25f;
130
131     // This number determines how small we are willing to reduce the page content
132     // in order to accommodate the widest line. If the page would have to be
133     // reduced smaller to make the widest line fit, we just clip instead (this
134     // behavior matches MacIE and Mozilla, at least)
135     const float PrintingMaximumShrinkFactor = 2.0f;
136
137     float minLayoutWidth = width * PrintingMinimumShrinkFactor;
138     float maxLayoutWidth = width * PrintingMaximumShrinkFactor;
139
140     // FIXME: This will modify the rendering of the on-screen frame.
141     // Could lead to flicker during printing.
142     m_frame->setPrinting(true, minLayoutWidth, maxLayoutWidth, true);
143 }
144
145 void PrintContext::spoolPage(GraphicsContext& ctx, int pageNumber, float width)
146 {
147     IntRect pageRect = m_pageRects[pageNumber];
148     float scale = width / pageRect.width();
149
150     ctx.save();
151     ctx.scale(FloatSize(scale, scale));
152     ctx.translate(-pageRect.x(), -pageRect.y());
153     ctx.clip(pageRect);
154     m_frame->view()->paintContents(&ctx, pageRect);
155     ctx.restore();
156 }
157
158 void PrintContext::end()
159 {
160     ASSERT(m_isPrinting);
161     m_isPrinting = false;
162     m_frame->setPrinting(false, 0, 0, true);
163 }
164
165 static RenderBoxModelObject* enclosingBoxModelObject(RenderObject* object)
166 {
167
168     while (object && !object->isBoxModelObject())
169         object = object->parent();
170     if (!object)
171         return 0;
172     return toRenderBoxModelObject(object);
173 }
174
175 int PrintContext::pageNumberForElement(Element* element, const FloatSize& pageSizeInPixels)
176 {
177     // Make sure the element is not freed during the layout.
178     RefPtr<Element> elementRef(element);
179     element->document()->updateLayout();
180
181     RenderBoxModelObject* box = enclosingBoxModelObject(element->renderer());
182     if (!box)
183         return -1;
184
185     Frame* frame = element->document()->frame();
186     FloatRect pageRect(FloatPoint(0, 0), pageSizeInPixels);
187     PrintContext printContext(frame);
188     printContext.begin(pageRect.width());
189     printContext.computePageRectsWithPageSize(pageSizeInPixels, false);
190
191     int top = box->offsetTop();
192     int left = box->offsetLeft();
193     int pageNumber = 0;
194     for (; pageNumber < printContext.pageCount(); pageNumber++) {
195         const IntRect& page = printContext.pageRect(pageNumber);
196         if (page.x() <= left && left < page.right() && page.y() <= top && top < page.bottom())
197             return pageNumber;
198     }
199     return -1;
200 }
201
202 String PrintContext::pageProperty(Frame* frame, const char* propertyName, int pageNumber)
203 {
204     Document* document = frame->document();
205     document->updateLayout();
206     RefPtr<RenderStyle> style = document->styleForPage(pageNumber);
207
208     // Implement formatters for properties we care about.
209     if (!strcmp(propertyName, "margin-left")) {
210         if (style->marginLeft().isAuto())
211             return String("auto");
212         return String::format("%d", style->marginLeft().rawValue());
213     }
214     if (!strcmp(propertyName, "line-height"))
215         return String::format("%d", style->lineHeight().rawValue());
216     if (!strcmp(propertyName, "font-size"))
217         return String::format("%d", style->fontDescription().computedPixelSize());
218     if (!strcmp(propertyName, "font-family"))
219         return String::format("%s", style->fontDescription().family().family().string().utf8().data());
220
221     return String::format("pageProperty() unimplemented for: %s", propertyName);
222 }
223
224 bool PrintContext::isPageBoxVisible(Frame* frame, int pageNumber)
225 {
226     return frame->document()->isPageBoxVisible(pageNumber);
227 }
228
229 String PrintContext::pageSizeAndMarginsInPixels(Frame* frame, int pageNumber, int width, int height, int marginTop, int marginRight, int marginBottom, int marginLeft)
230 {
231     IntSize pageSize(width, height);
232     frame->document()->pageSizeAndMarginsInPixels(pageNumber, pageSize, marginTop, marginRight, marginBottom, marginLeft);
233     return String::format("(%d, %d) %d %d %d %d", pageSize.width(), pageSize.height(), marginTop, marginRight, marginBottom, marginLeft);
234 }
235
236 int PrintContext::numberOfPages(Frame* frame, const FloatSize& pageSizeInPixels)
237 {
238     frame->document()->updateLayout();
239
240     FloatRect pageRect(FloatPoint(0, 0), pageSizeInPixels);
241     PrintContext printContext(frame);
242     printContext.begin(pageRect.width());
243     printContext.computePageRectsWithPageSize(pageSizeInPixels, false);
244     return printContext.pageCount();
245 }
246
247 }