2010-04-30 Shinichiro Hamaji <hamaji@chromium.org>
[WebKit.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 "RenderView.h"
28
29 using namespace WebCore;
30
31 namespace WebCore {
32
33 PrintContext::PrintContext(Frame* frame)
34     : m_frame(frame)
35     , m_isPrinting(false)
36 {
37 }
38
39 PrintContext::~PrintContext()
40 {
41     if (m_isPrinting)
42         end();
43     m_pageRects.clear();
44 }
45
46 int PrintContext::pageCount() const
47 {
48     return m_pageRects.size();
49 }
50
51 const IntRect& PrintContext::pageRect(int pageNumber) const
52 {
53     return m_pageRects[pageNumber];
54 }
55
56 void PrintContext::computePageRects(const FloatRect& printRect, float headerHeight, float footerHeight, float userScaleFactor, float& outPageHeight)
57 {
58     m_pageRects.clear();
59     outPageHeight = 0;
60
61     if (!m_frame->document() || !m_frame->view() || !m_frame->document()->renderer())
62         return;
63
64     if (userScaleFactor <= 0) {
65         LOG_ERROR("userScaleFactor has bad value %.2f", userScaleFactor);
66         return;
67     }
68
69     RenderView* root = toRenderView(m_frame->document()->renderer());
70
71     float ratio = printRect.height() / printRect.width();
72
73     float pageWidth  = (float)root->rightLayoutOverflow();
74     float pageHeight = pageWidth * ratio;
75     outPageHeight = pageHeight; // this is the height of the page adjusted by margins
76     pageHeight -= headerHeight + footerHeight;
77
78     if (pageHeight <= 0) {
79         LOG_ERROR("pageHeight has bad value %.2f", pageHeight);
80         return;
81     }
82
83     computePageRectsWithPageSizeInternal(FloatSize(pageWidth / userScaleFactor, pageHeight / userScaleFactor), false);
84 }
85
86 void PrintContext::computePageRectsWithPageSize(const FloatSize& pageSizeInPixels, bool allowHorizontalMultiPages)
87 {
88     m_pageRects.clear();
89     computePageRectsWithPageSizeInternal(pageSizeInPixels, allowHorizontalMultiPages);
90 }
91
92 void PrintContext::computePageRectsWithPageSizeInternal(const FloatSize& pageSizeInPixels, bool allowHorizontalMultiPages)
93 {
94     if (!m_frame->document() || !m_frame->view() || !m_frame->document()->renderer())
95         return;
96     RenderView* root = toRenderView(m_frame->document()->renderer());
97
98     const float pageWidth = pageSizeInPixels.width();
99     const float docWidth = root->layer()->width();
100     const float docHeight = root->layer()->height();
101     float currPageHeight = pageSizeInPixels.height();
102
103     // always return at least one page, since empty files should print a blank page
104     float printedPagesHeight = 0;
105     do {
106         float proposedBottom = std::min(docHeight, printedPagesHeight + pageSizeInPixels.height());
107         m_frame->view()->adjustPageHeight(&proposedBottom, printedPagesHeight, proposedBottom, printedPagesHeight);
108         currPageHeight = max(1.0f, proposedBottom - printedPagesHeight);
109         if (allowHorizontalMultiPages) {
110             for (float curWidth = 0; curWidth < docWidth; curWidth += pageWidth)
111                 m_pageRects.append(IntRect(curWidth, (int)printedPagesHeight, (int)pageWidth, (int)currPageHeight));
112         } else
113             m_pageRects.append(IntRect(0, (int)printedPagesHeight, (int)pageWidth, (int)currPageHeight));
114         printedPagesHeight += currPageHeight;
115     } while (printedPagesHeight < docHeight);
116 }
117
118 void PrintContext::begin(float width)
119 {
120     ASSERT(!m_isPrinting);
121     m_isPrinting = true;
122
123     // By imaging to a width a little wider than the available pixels,
124     // thin pages will be scaled down a little, matching the way they
125     // print in IE and Camino. This lets them use fewer sheets than they
126     // would otherwise, which is presumably why other browsers do this.
127     // Wide pages will be scaled down more than this.
128     const float PrintingMinimumShrinkFactor = 1.25f;
129
130     // This number determines how small we are willing to reduce the page content
131     // in order to accommodate the widest line. If the page would have to be
132     // reduced smaller to make the widest line fit, we just clip instead (this
133     // behavior matches MacIE and Mozilla, at least)
134     const float PrintingMaximumShrinkFactor = 2.0f;
135
136     float minLayoutWidth = width * PrintingMinimumShrinkFactor;
137     float maxLayoutWidth = width * PrintingMaximumShrinkFactor;
138
139     // FIXME: This will modify the rendering of the on-screen frame.
140     // Could lead to flicker during printing.
141     m_frame->setPrinting(true, minLayoutWidth, maxLayoutWidth, true);
142 }
143
144 void PrintContext::spoolPage(GraphicsContext& ctx, int pageNumber, float width)
145 {
146     IntRect pageRect = m_pageRects[pageNumber];
147     float scale = width / pageRect.width();
148
149     ctx.save();
150     ctx.scale(FloatSize(scale, scale));
151     ctx.translate(-pageRect.x(), -pageRect.y());
152     ctx.clip(pageRect);
153     m_frame->view()->paintContents(&ctx, pageRect);
154     ctx.restore();
155 }
156
157 void PrintContext::end()
158 {
159     ASSERT(m_isPrinting);
160     m_isPrinting = false;
161     m_frame->setPrinting(false, 0, 0, true);
162 }
163
164 static RenderBoxModelObject* enclosingBoxModelObject(RenderObject* object)
165 {
166
167     while (object && !object->isBoxModelObject())
168         object = object->parent();
169     if (!object)
170         return 0;
171     return toRenderBoxModelObject(object);
172 }
173
174 int PrintContext::pageNumberForElement(Element* element, const FloatSize& pageSizeInPixels)
175 {
176     // Make sure the element is not freed during the layout.
177     RefPtr<Element> elementRef(element);
178     element->document()->updateLayout();
179
180     RenderBoxModelObject* box = enclosingBoxModelObject(element->renderer());
181     if (!box)
182         return -1;
183
184     Frame* frame = element->document()->frame();
185     FloatRect pageRect(FloatPoint(0, 0), pageSizeInPixels);
186     PrintContext printContext(frame);
187     printContext.begin(pageRect.width());
188     printContext.computePageRectsWithPageSize(pageSizeInPixels, 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 int PrintContext::numberOfPages(Frame* frame, const FloatSize& pageSizeInPixels)
202 {
203     frame->document()->updateLayout();
204
205     FloatRect pageRect(FloatPoint(0, 0), pageSizeInPixels);
206     PrintContext printContext(frame);
207     printContext.begin(pageRect.width());
208     printContext.computePageRectsWithPageSize(pageSizeInPixels, false);
209     return printContext.pageCount();
210 }
211
212 }