28e4e7498fd69f7a3af8af9505ba5737cb67514c
[WebKit-https.git] / Source / WebCore / rendering / RenderMarquee.cpp
1 /*
2  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
3  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
4  *
5  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
6  *
7  * Other contributors:
8  *   Robert O'Callahan <roc+@cs.cmu.edu>
9  *   David Baron <dbaron@fas.harvard.edu>
10  *   Christian Biesinger <cbiesinger@web.de>
11  *   Randall Jesup <rjesup@wgate.com>
12  *   Roland Mainz <roland.mainz@informatik.med.uni-giessen.de>
13  *   Josh Soref <timeless@mac.com>
14  *   Boris Zbarsky <bzbarsky@mit.edu>
15  *
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  *
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  *
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
29  *
30  * Alternatively, the contents of this file may be used under the terms
31  * of either the Mozilla Public License Version 1.1, found at
32  * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public
33  * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html
34  * (the "GPL"), in which case the provisions of the MPL or the GPL are
35  * applicable instead of those above.  If you wish to allow use of your
36  * version of this file only under the terms of one of those two
37  * licenses (the MPL or the GPL) and not to allow others to use your
38  * version of this file under the LGPL, indicate your decision by
39  * deletingthe provisions above and replace them with the notice and
40  * other provisions required by the MPL or the GPL, as the case may be.
41  * If you do not delete the provisions above, a recipient may use your
42  * version of this file under any of the LGPL, the MPL or the GPL.
43  */
44
45 #include "config.h"
46
47 #include "RenderMarquee.h"
48
49 #include "FrameView.h"
50 #include "HTMLMarqueeElement.h"
51 #include "HTMLNames.h"
52 #include "RenderLayer.h"
53 #include "RenderView.h"
54
55 namespace WebCore {
56
57 using namespace HTMLNames;
58
59 RenderMarquee::RenderMarquee(RenderLayer* l)
60     : m_layer(l), m_currentLoop(0)
61     , m_totalLoops(0)
62     , m_timer(this, &RenderMarquee::timerFired)
63     , m_start(0), m_end(0), m_speed(0), m_reset(false)
64     , m_suspended(false), m_stopped(false), m_direction(MAUTO)
65 {
66 }
67
68 RenderMarquee::~RenderMarquee()
69 {
70 }
71
72 int RenderMarquee::marqueeSpeed() const
73 {
74     int result = m_layer->renderer().style().marqueeSpeed();
75     Element* element = m_layer->renderer().element();
76     if (element && element->hasTagName(marqueeTag))
77         result = std::max(result, toHTMLMarqueeElement(element)->minimumDelay());
78     return result;
79 }
80
81 EMarqueeDirection RenderMarquee::direction() const
82 {
83     // FIXME: Support the CSS3 "auto" value for determining the direction of the marquee.
84     // For now just map MAUTO to MBACKWARD
85     EMarqueeDirection result = m_layer->renderer().style().marqueeDirection();
86     TextDirection dir = m_layer->renderer().style().direction();
87     if (result == MAUTO)
88         result = MBACKWARD;
89     if (result == MFORWARD)
90         result = (dir == LTR) ? MRIGHT : MLEFT;
91     if (result == MBACKWARD)
92         result = (dir == LTR) ? MLEFT : MRIGHT;
93     
94     // Now we have the real direction.  Next we check to see if the increment is negative.
95     // If so, then we reverse the direction.
96     Length increment = m_layer->renderer().style().marqueeIncrement();
97     if (increment.isNegative())
98         result = static_cast<EMarqueeDirection>(-result);
99     
100     return result;
101 }
102
103 bool RenderMarquee::isHorizontal() const
104 {
105     return direction() == MLEFT || direction() == MRIGHT;
106 }
107
108 int RenderMarquee::computePosition(EMarqueeDirection dir, bool stopAtContentEdge)
109 {
110     RenderBox* box = m_layer->renderBox();
111     ASSERT(box);
112     RenderStyle& boxStyle = box->style();
113     if (isHorizontal()) {
114         bool ltr = boxStyle.isLeftToRightDirection();
115         LayoutUnit clientWidth = box->clientWidth();
116         LayoutUnit contentWidth = ltr ? box->maxPreferredLogicalWidth() : box->minPreferredLogicalWidth();
117         if (ltr)
118             contentWidth += (box->paddingRight() - box->borderLeft());
119         else {
120             contentWidth = box->width() - contentWidth;
121             contentWidth += (box->paddingLeft() - box->borderRight());
122         }
123         if (dir == MRIGHT) {
124             if (stopAtContentEdge)
125                 return std::max<LayoutUnit>(0, ltr ? (contentWidth - clientWidth) : (clientWidth - contentWidth));
126             else
127                 return ltr ? contentWidth : clientWidth;
128         }
129         else {
130             if (stopAtContentEdge)
131                 return std::min<LayoutUnit>(0, ltr ? (contentWidth - clientWidth) : (clientWidth - contentWidth));
132             else
133                 return ltr ? -clientWidth : -contentWidth;
134         }
135     }
136     else {
137         int contentHeight = box->layoutOverflowRect().maxY() - box->borderTop() + box->paddingBottom();
138         int clientHeight = box->clientHeight();
139         if (dir == MUP) {
140             if (stopAtContentEdge)
141                  return std::min(contentHeight - clientHeight, 0);
142             else
143                 return -clientHeight;
144         }
145         else {
146             if (stopAtContentEdge)
147                 return std::max(contentHeight - clientHeight, 0);
148             else 
149                 return contentHeight;
150         }
151     }    
152 }
153
154 void RenderMarquee::start()
155 {
156     if (m_timer.isActive() || m_layer->renderer().style().marqueeIncrement().isZero())
157         return;
158
159     // We may end up propagating a scroll event. It is important that we suspend events until 
160     // the end of the function since they could delete the layer, including the marquee.
161     FrameView& frameView = m_layer->renderer().view().frameView();
162     frameView.pauseScheduledEvents();
163
164     if (!m_suspended && !m_stopped) {
165         if (isHorizontal())
166             m_layer->scrollToOffset(IntSize(m_start, 0));
167         else
168             m_layer->scrollToOffset(IntSize(0, m_start));
169     }
170     else {
171         m_suspended = false;
172         m_stopped = false;
173     }
174
175     m_timer.startRepeating(speed() * 0.001);
176
177     frameView.resumeScheduledEvents();
178 }
179
180 void RenderMarquee::suspend()
181 {
182     m_timer.stop();
183     m_suspended = true;
184 }
185
186 void RenderMarquee::stop()
187 {
188     m_timer.stop();
189     m_stopped = true;
190 }
191
192 void RenderMarquee::updateMarqueePosition()
193 {
194     bool activate = (m_totalLoops <= 0 || m_currentLoop < m_totalLoops);
195     if (activate) {
196         EMarqueeBehavior behavior = m_layer->renderer().style().marqueeBehavior();
197         m_start = computePosition(direction(), behavior == MALTERNATE);
198         m_end = computePosition(reverseDirection(), behavior == MALTERNATE || behavior == MSLIDE);
199         if (!m_stopped)
200             start();
201     }
202 }
203
204 void RenderMarquee::updateMarqueeStyle()
205 {
206     RenderStyle& style = m_layer->renderer().style();
207     
208     if (m_direction != style.marqueeDirection() || (m_totalLoops != style.marqueeLoopCount() && m_currentLoop >= m_totalLoops))
209         m_currentLoop = 0; // When direction changes or our loopCount is a smaller number than our current loop, reset our loop.
210     
211     m_totalLoops = style.marqueeLoopCount();
212     m_direction = style.marqueeDirection();
213     
214     if (m_layer->renderer().isHTMLMarquee()) {
215         // Hack for WinIE.  In WinIE, a value of 0 or lower for the loop count for SLIDE means to only do
216         // one loop.
217         if (m_totalLoops <= 0 && style.marqueeBehavior() == MSLIDE)
218             m_totalLoops = 1;
219         
220         // Hack alert: Set the white-space value to nowrap for horizontal marquees with inline children, thus ensuring
221         // all the text ends up on one line by default.  Limit this hack to the <marquee> element to emulate
222         // WinIE's behavior.  Someone using CSS3 can use white-space: nowrap on their own to get this effect.
223         // Second hack alert: Set the text-align back to auto.  WinIE completely ignores text-align on the
224         // marquee element.
225         // FIXME: Bring these up with the CSS WG.
226         if (isHorizontal() && m_layer->renderer().childrenInline()) {
227             style.setWhiteSpace(NOWRAP);
228             style.setTextAlign(TASTART);
229         }
230     }
231     
232     // Legacy hack - multiple browsers default vertical marquees to 200px tall.
233     if (!isHorizontal() && style.height().isAuto())
234         style.setHeight(Length(200, Fixed)); 
235    
236     if (speed() != marqueeSpeed()) {
237         m_speed = marqueeSpeed();
238         if (m_timer.isActive())
239             m_timer.startRepeating(speed() * 0.001);
240     }
241     
242     // Check the loop count to see if we should now stop.
243     bool activate = (m_totalLoops <= 0 || m_currentLoop < m_totalLoops);
244     if (activate && !m_timer.isActive())
245         m_layer->renderer().setNeedsLayout();
246     else if (!activate && m_timer.isActive())
247         m_timer.stop();
248 }
249
250 void RenderMarquee::timerFired(Timer<RenderMarquee>*)
251 {
252     if (m_layer->renderer().view().needsLayout())
253         return;
254     
255     if (m_reset) {
256         m_reset = false;
257         if (isHorizontal())
258             m_layer->scrollToXOffset(m_start);
259         else
260             m_layer->scrollToYOffset(m_start);
261         return;
262     }
263     
264     const RenderStyle& style = m_layer->renderer().style();
265     
266     int endPoint = m_end;
267     int range = m_end - m_start;
268     int newPos;
269     if (range == 0)
270         newPos = m_end;
271     else {  
272         bool addIncrement = direction() == MUP || direction() == MLEFT;
273         bool isReversed = style.marqueeBehavior() == MALTERNATE && m_currentLoop % 2;
274         if (isReversed) {
275             // We're going in the reverse direction.
276             endPoint = m_start;
277             range = -range;
278             addIncrement = !addIncrement;
279         }
280         bool positive = range > 0;
281         int clientSize = (isHorizontal() ? m_layer->renderBox()->clientWidth() : m_layer->renderBox()->clientHeight());
282         int increment = abs(intValueForLength(m_layer->renderer().style().marqueeIncrement(), clientSize));
283         int currentPos = (isHorizontal() ? m_layer->scrollXOffset() : m_layer->scrollYOffset());
284         newPos =  currentPos + (addIncrement ? increment : -increment);
285         if (positive)
286             newPos = std::min(newPos, endPoint);
287         else
288             newPos = std::max(newPos, endPoint);
289     }
290
291     if (newPos == endPoint) {
292         m_currentLoop++;
293         if (m_totalLoops > 0 && m_currentLoop >= m_totalLoops)
294             m_timer.stop();
295         else if (style.marqueeBehavior() != MALTERNATE)
296             m_reset = true;
297     }
298     
299     if (isHorizontal())
300         m_layer->scrollToXOffset(newPos);
301     else
302         m_layer->scrollToYOffset(newPos);
303 }
304
305 } // namespace WebCore