unicode-bidi should support isolate override and override isolate
[WebKit-https.git] / Source / WebCore / rendering / RenderListBox.cpp
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
3  *               2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1.  Redistributions of source code must retain the above copyright
10  *     notice, this list of conditions and the following disclaimer. 
11  * 2.  Redistributions in binary form must reproduce the above copyright
12  *     notice, this list of conditions and the following disclaimer in the
13  *     documentation and/or other materials provided with the distribution. 
14  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
15  *     its contributors may be used to endorse or promote products derived
16  *     from this software without specific prior written permission. 
17  *
18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #include "config.h"
31 #include "RenderListBox.h"
32
33 #include "AXObjectCache.h"
34 #include "CSSFontSelector.h"
35 #include "CSSStyleSelector.h"
36 #include "Document.h"
37 #include "DocumentEventQueue.h"
38 #include "EventHandler.h"
39 #include "FocusController.h"
40 #include "FontCache.h"
41 #include "Frame.h"
42 #include "FrameSelection.h"
43 #include "FrameView.h"
44 #include "GraphicsContext.h"
45 #include "HTMLNames.h"
46 #include "HTMLOptionElement.h"
47 #include "HTMLOptGroupElement.h"
48 #include "HTMLSelectElement.h"
49 #include "HitTestResult.h"
50 #include "NodeRenderStyle.h"
51 #include "Page.h"
52 #include "PaintInfo.h"
53 #include "RenderLayer.h"
54 #include "RenderScrollbar.h"
55 #include "RenderText.h"
56 #include "RenderTheme.h"
57 #include "RenderView.h"
58 #include "Scrollbar.h"
59 #include "ScrollbarTheme.h"
60 #include "SpatialNavigation.h"
61 #include <math.h>
62
63 using namespace std;
64
65 namespace WebCore {
66
67 using namespace HTMLNames;
68  
69 const int rowSpacing = 1;
70
71 const int optionsSpacingHorizontal = 2;
72
73 // The minSize constant was originally defined to render scrollbars correctly.
74 // This might vary for different platforms.
75 const int minSize = 4;
76
77 // Default size when the multiple attribute is present but size attribute is absent.
78 const int defaultSize = 4;
79
80 // FIXME: This hardcoded baselineAdjustment is what we used to do for the old
81 // widget, but I'm not sure this is right for the new control.
82 const int baselineAdjustment = 7;
83
84 RenderListBox::RenderListBox(Element* element)
85     : RenderBlock(element)
86     , m_optionsChanged(true)
87     , m_scrollToRevealSelectionAfterLayout(false)
88     , m_inAutoscroll(false)
89     , m_optionsWidth(0)
90     , m_indexOffset(0)
91 {
92     ASSERT(element);
93     ASSERT(element->isHTMLElement());
94     ASSERT(element->hasTagName(HTMLNames::selectTag));
95
96     if (FrameView* frameView = frame()->view())
97         frameView->addScrollableArea(this);
98 }
99
100 RenderListBox::~RenderListBox()
101 {
102     setHasVerticalScrollbar(false);
103
104     if (FrameView* frameView = frame()->view())
105         frameView->removeScrollableArea(this);
106 }
107
108 void RenderListBox::updateFromElement()
109 {
110     FontCachePurgePreventer fontCachePurgePreventer;
111
112     if (m_optionsChanged) {
113         const Vector<HTMLElement*>& listItems = toHTMLSelectElement(node())->listItems();
114         int size = numItems();
115         
116         float width = 0;
117         for (int i = 0; i < size; ++i) {
118             HTMLElement* element = listItems[i];
119             String text;
120             Font itemFont = style()->font();
121             if (element->hasTagName(optionTag))
122                 text = toHTMLOptionElement(element)->textIndentedToRespectGroupLabel();
123             else if (element->hasTagName(optgroupTag)) {
124                 text = static_cast<const HTMLOptGroupElement*>(element)->groupLabelText();
125                 FontDescription d = itemFont.fontDescription();
126                 d.setWeight(d.bolderWeight());
127                 itemFont = Font(d, itemFont.letterSpacing(), itemFont.wordSpacing());
128                 itemFont.update(document()->styleSelector()->fontSelector());
129             }
130
131             if (!text.isEmpty()) {
132                 applyTextTransform(style(), text, ' ');
133                 // FIXME: Why is this always LTR? Can't text direction affect the width?
134                 TextRun textRun = constructTextRun(this, itemFont, text, style(), TextRun::AllowTrailingExpansion);
135                 textRun.disableRoundingHacks();
136                 float textWidth = itemFont.width(textRun);
137                 width = max(width, textWidth);
138             }
139         }
140         m_optionsWidth = static_cast<int>(ceilf(width));
141         m_optionsChanged = false;
142         
143         setHasVerticalScrollbar(true);
144
145         setNeedsLayoutAndPrefWidthsRecalc();
146     }
147 }
148
149 void RenderListBox::selectionChanged()
150 {
151     repaint();
152     if (!m_inAutoscroll) {
153         if (m_optionsChanged || needsLayout())
154             m_scrollToRevealSelectionAfterLayout = true;
155         else
156             scrollToRevealSelection();
157     }
158     
159     if (AXObjectCache::accessibilityEnabled())
160         document()->axObjectCache()->selectedChildrenChanged(this);
161 }
162
163 void RenderListBox::layout()
164 {
165     RenderBlock::layout();
166     if (m_scrollToRevealSelectionAfterLayout) {
167         LayoutStateDisabler layoutStateDisabler(view());
168         scrollToRevealSelection();
169     }
170 }
171
172 void RenderListBox::scrollToRevealSelection()
173 {    
174     HTMLSelectElement* select = toHTMLSelectElement(node());
175
176     m_scrollToRevealSelectionAfterLayout = false;
177
178     int firstIndex = select->activeSelectionStartListIndex();
179     if (firstIndex >= 0 && !listIndexIsVisible(select->activeSelectionEndListIndex()))
180         scrollToRevealElementAtListIndex(firstIndex);
181 }
182
183 void RenderListBox::computePreferredLogicalWidths()
184 {
185     ASSERT(!m_optionsChanged);
186
187     m_minPreferredLogicalWidth = 0;
188     m_maxPreferredLogicalWidth = 0;
189
190     if (style()->width().isFixed() && style()->width().value() > 0)
191         m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = computeContentBoxLogicalWidth(style()->width().value());
192     else {
193         m_maxPreferredLogicalWidth = m_optionsWidth + 2 * optionsSpacingHorizontal;
194         if (m_vBar)
195             m_maxPreferredLogicalWidth += m_vBar->width();
196     }
197
198     if (style()->minWidth().isFixed() && style()->minWidth().value() > 0) {
199         m_maxPreferredLogicalWidth = max(m_maxPreferredLogicalWidth, computeContentBoxLogicalWidth(style()->minWidth().value()));
200         m_minPreferredLogicalWidth = max(m_minPreferredLogicalWidth, computeContentBoxLogicalWidth(style()->minWidth().value()));
201     } else if (style()->width().isPercent() || (style()->width().isAuto() && style()->height().isPercent()))
202         m_minPreferredLogicalWidth = 0;
203     else
204         m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth;
205
206     if (style()->maxWidth().isFixed()) {
207         m_maxPreferredLogicalWidth = min(m_maxPreferredLogicalWidth, computeContentBoxLogicalWidth(style()->maxWidth().value()));
208         m_minPreferredLogicalWidth = min(m_minPreferredLogicalWidth, computeContentBoxLogicalWidth(style()->maxWidth().value()));
209     }
210
211     LayoutUnit toAdd = borderAndPaddingWidth();
212     m_minPreferredLogicalWidth += toAdd;
213     m_maxPreferredLogicalWidth += toAdd;
214                                 
215     setPreferredLogicalWidthsDirty(false);
216 }
217
218 int RenderListBox::size() const
219 {
220     int specifiedSize = toHTMLSelectElement(node())->size();
221     if (specifiedSize > 1)
222         return max(minSize, specifiedSize);
223
224     return defaultSize;
225 }
226
227 int RenderListBox::numVisibleItems() const
228 {
229     // Only count fully visible rows. But don't return 0 even if only part of a row shows.
230     return max<int>(1, (contentHeight() + rowSpacing) / itemHeight());
231 }
232
233 int RenderListBox::numItems() const
234 {
235     return toHTMLSelectElement(node())->listItems().size();
236 }
237
238 LayoutUnit RenderListBox::listHeight() const
239 {
240     return itemHeight() * numItems() - rowSpacing;
241 }
242
243 void RenderListBox::computeLogicalHeight()
244 {
245     int toAdd = borderAndPaddingHeight();
246  
247     int itemHeight = RenderListBox::itemHeight();
248     setHeight(itemHeight * size() - rowSpacing + toAdd);
249     
250     RenderBlock::computeLogicalHeight();
251     
252     if (m_vBar) {
253         bool enabled = numVisibleItems() < numItems();
254         m_vBar->setEnabled(enabled);
255         m_vBar->setSteps(1, max(1, numVisibleItems() - 1), itemHeight);
256         m_vBar->setProportion(numVisibleItems(), numItems());
257         if (!enabled) {
258             scrollToOffsetWithoutAnimation(VerticalScrollbar, 0);
259             m_indexOffset = 0;
260         }
261     }
262 }
263
264 LayoutUnit RenderListBox::baselinePosition(FontBaseline baselineType, bool firstLine, LineDirectionMode lineDirection, LinePositionMode linePositionMode) const
265 {
266     return RenderBox::baselinePosition(baselineType, firstLine, lineDirection, linePositionMode) - baselineAdjustment;
267 }
268
269 LayoutRect RenderListBox::itemBoundingBoxRect(const LayoutPoint& additionalOffset, int index)
270 {
271     return LayoutRect(additionalOffset.x() + borderLeft() + paddingLeft(),
272                    additionalOffset.y() + borderTop() + paddingTop() + itemHeight() * (index - m_indexOffset),
273                    contentWidth(), itemHeight());
274 }
275     
276 void RenderListBox::paintObject(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
277 {
278     if (style()->visibility() != VISIBLE)
279         return;
280     
281     int listItemsSize = numItems();
282
283     if (paintInfo.phase == PaintPhaseForeground) {
284         int index = m_indexOffset;
285         while (index < listItemsSize && index <= m_indexOffset + numVisibleItems()) {
286             paintItemForeground(paintInfo, paintOffset, index);
287             index++;
288         }
289     }
290
291     // Paint the children.
292     RenderBlock::paintObject(paintInfo, paintOffset);
293
294     switch (paintInfo.phase) {
295     // Depending on whether we have overlay scrollbars they
296     // get rendered in the foreground or background phases
297     case PaintPhaseForeground:
298         if (m_vBar->isOverlayScrollbar())
299             paintScrollbar(paintInfo, paintOffset);
300         break;
301     case PaintPhaseBlockBackground:
302         if (!m_vBar->isOverlayScrollbar())
303             paintScrollbar(paintInfo, paintOffset);
304         break;
305     case PaintPhaseChildBlockBackground:
306     case PaintPhaseChildBlockBackgrounds: {
307         int index = m_indexOffset;
308         while (index < listItemsSize && index <= m_indexOffset + numVisibleItems()) {
309             paintItemBackground(paintInfo, paintOffset, index);
310             index++;
311         }
312         break;
313     }
314     default:
315         break;
316     }
317 }
318
319 void RenderListBox::addFocusRingRects(Vector<LayoutRect>& rects, const LayoutPoint& additionalOffset)
320 {
321     if (!isSpatialNavigationEnabled(frame()))
322         return RenderBlock::addFocusRingRects(rects, additionalOffset);
323
324     HTMLSelectElement* select = toHTMLSelectElement(node());
325
326     // Focus the last selected item.
327     int selectedItem = select->activeSelectionEndListIndex();
328     if (selectedItem >= 0) {
329         rects.append(itemBoundingBoxRect(additionalOffset, selectedItem));
330         return;
331     }
332
333     // No selected items, find the first non-disabled item.
334     int size = numItems();
335     const Vector<HTMLElement*>& listItems = select->listItems();
336     for (int i = 0; i < size; ++i) {
337         HTMLElement* element = listItems[i];
338         if (element->hasTagName(optionTag) && !toHTMLOptionElement(element)->disabled()) {
339             rects.append(itemBoundingBoxRect(additionalOffset, i));
340             return;
341         }
342     }
343 }
344
345 void RenderListBox::paintScrollbar(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
346 {
347     if (m_vBar) {
348         LayoutRect scrollRect(paintOffset.x() + width() - borderRight() - m_vBar->width(),
349             paintOffset.y() + borderTop(),
350             m_vBar->width(),
351             height() - (borderTop() + borderBottom()));
352         m_vBar->setFrameRect(scrollRect);
353         m_vBar->paint(paintInfo.context, paintInfo.rect);
354     }
355 }
356
357 static LayoutSize itemOffsetForAlignment(TextRun textRun, RenderStyle* itemStyle, Font itemFont, LayoutRect itemBoudingBox)
358 {
359     ETextAlign actualAlignment = itemStyle->textAlign();
360     // FIXME: Firefox doesn't respect JUSTIFY. Should we?
361     if (actualAlignment == TAAUTO || actualAlignment == JUSTIFY)
362       actualAlignment = itemStyle->isLeftToRightDirection() ? LEFT : RIGHT;
363
364     LayoutSize offset = LayoutSize(0, itemFont.fontMetrics().ascent());
365     if (actualAlignment == RIGHT || actualAlignment == WEBKIT_RIGHT) {
366         float textWidth = itemFont.width(textRun);
367         offset.setWidth(itemBoudingBox.width() - textWidth - optionsSpacingHorizontal);
368     } else if (actualAlignment == CENTER || actualAlignment == WEBKIT_CENTER) {
369         float textWidth = itemFont.width(textRun);
370         offset.setWidth((itemBoudingBox.width() - textWidth) / 2);
371     } else
372         offset.setWidth(optionsSpacingHorizontal);
373     return offset;
374 }
375
376 void RenderListBox::paintItemForeground(PaintInfo& paintInfo, const LayoutPoint& paintOffset, int listIndex)
377 {
378     FontCachePurgePreventer fontCachePurgePreventer;
379
380     const Vector<HTMLElement*>& listItems = toHTMLSelectElement(node())->listItems();
381     HTMLElement* element = listItems[listIndex];
382
383     RenderStyle* itemStyle = element->renderStyle();
384     if (!itemStyle)
385         itemStyle = style();
386
387     if (itemStyle->visibility() == HIDDEN)
388         return;
389
390     String itemText;
391     bool isOptionElement = element->hasTagName(optionTag);
392     if (isOptionElement)
393         itemText = toHTMLOptionElement(element)->textIndentedToRespectGroupLabel();
394     else if (element->hasTagName(optgroupTag))
395         itemText = static_cast<const HTMLOptGroupElement*>(element)->groupLabelText();
396     applyTextTransform(style(), itemText, ' ');
397
398     Color textColor = element->renderStyle() ? element->renderStyle()->visitedDependentColor(CSSPropertyColor) : style()->visitedDependentColor(CSSPropertyColor);
399     if (isOptionElement && toHTMLOptionElement(element)->selected()) {
400         if (frame()->selection()->isFocusedAndActive() && document()->focusedNode() == node())
401             textColor = theme()->activeListBoxSelectionForegroundColor();
402         // Honor the foreground color for disabled items
403         else if (!element->disabled())
404             textColor = theme()->inactiveListBoxSelectionForegroundColor();
405     }
406
407     ColorSpace colorSpace = itemStyle->colorSpace();
408     paintInfo.context->setFillColor(textColor, colorSpace);
409
410     unsigned length = itemText.length();
411     const UChar* string = itemText.characters();
412     TextRun textRun(string, length, false, 0, 0, TextRun::AllowTrailingExpansion, itemStyle->direction(), isOverride(itemStyle->unicodeBidi()), TextRun::NoRounding);
413     Font itemFont = style()->font();
414     LayoutRect r = itemBoundingBoxRect(paintOffset, listIndex);
415     r.move(itemOffsetForAlignment(textRun, itemStyle, itemFont, r));
416
417     if (element->hasTagName(optgroupTag)) {
418         FontDescription d = itemFont.fontDescription();
419         d.setWeight(d.bolderWeight());
420         itemFont = Font(d, itemFont.letterSpacing(), itemFont.wordSpacing());
421         itemFont.update(document()->styleSelector()->fontSelector());
422     }
423
424     // Draw the item text
425     paintInfo.context->drawBidiText(itemFont, textRun, r.location());
426 }
427
428 void RenderListBox::paintItemBackground(PaintInfo& paintInfo, const LayoutPoint& paintOffset, int listIndex)
429 {
430     const Vector<HTMLElement*>& listItems = toHTMLSelectElement(node())->listItems();
431     HTMLElement* element = listItems[listIndex];
432
433     Color backColor;
434     if (element->hasTagName(optionTag) && toHTMLOptionElement(element)->selected()) {
435         if (frame()->selection()->isFocusedAndActive() && document()->focusedNode() == node())
436             backColor = theme()->activeListBoxSelectionBackgroundColor();
437         else
438             backColor = theme()->inactiveListBoxSelectionBackgroundColor();
439     } else
440         backColor = element->renderStyle() ? element->renderStyle()->visitedDependentColor(CSSPropertyBackgroundColor) : style()->visitedDependentColor(CSSPropertyBackgroundColor);
441
442     // Draw the background for this list box item
443     if (!element->renderStyle() || element->renderStyle()->visibility() != HIDDEN) {
444         ColorSpace colorSpace = element->renderStyle() ? element->renderStyle()->colorSpace() : style()->colorSpace();
445         LayoutRect itemRect = itemBoundingBoxRect(paintOffset, listIndex);
446         itemRect.intersect(controlClipRect(paintOffset));
447         paintInfo.context->fillRect(itemRect, backColor, colorSpace);
448     }
449 }
450
451 bool RenderListBox::isPointInOverflowControl(HitTestResult& result, const LayoutPoint& pointInContainer, const LayoutPoint& accumulatedOffset)
452 {
453     if (!m_vBar || !m_vBar->shouldParticipateInHitTesting())
454         return false;
455
456     LayoutRect vertRect(accumulatedOffset.x() + width() - borderRight() - m_vBar->width(),
457                         accumulatedOffset.y() + borderTop(),
458                         m_vBar->width(),
459                         height() - borderTop() - borderBottom());
460
461     if (vertRect.contains(pointInContainer)) {
462         result.setScrollbar(m_vBar.get());
463         return true;
464     }
465     return false;
466 }
467
468 int RenderListBox::listIndexAtOffset(const LayoutSize& offset)
469 {
470     if (!numItems())
471         return -1;
472
473     if (offset.height() < borderTop() + paddingTop() || offset.height() > height() - paddingBottom() - borderBottom())
474         return -1;
475
476     int scrollbarWidth = m_vBar ? m_vBar->width() : 0;
477     if (offset.width() < borderLeft() + paddingLeft() || offset.width() > width() - borderRight() - paddingRight() - scrollbarWidth)
478         return -1;
479
480     int newOffset = (offset.height() - borderTop() - paddingTop()) / itemHeight() + m_indexOffset;
481     return newOffset < numItems() ? newOffset : -1;
482 }
483
484 void RenderListBox::panScroll(const IntPoint& panStartMousePosition)
485 {
486     const int maxSpeed = 20;
487     const int iconRadius = 7;
488     const int speedReducer = 4;
489
490     // FIXME: This doesn't work correctly with transforms.
491     FloatPoint absOffset = localToAbsolute();
492
493     IntPoint currentMousePosition = roundedIntPoint(frame()->eventHandler()->currentMousePosition());
494     // We need to check if the current mouse position is out of the window. When the mouse is out of the window, the position is incoherent
495     static IntPoint previousMousePosition;
496     if (currentMousePosition.y() < 0)
497         currentMousePosition = previousMousePosition;
498     else
499         previousMousePosition = currentMousePosition;
500
501     int yDelta = currentMousePosition.y() - panStartMousePosition.y();
502
503     // If the point is too far from the center we limit the speed
504     yDelta = max<int>(min<int>(yDelta, maxSpeed), -maxSpeed);
505     
506     if (abs(yDelta) < iconRadius) // at the center we let the space for the icon
507         return;
508
509     if (yDelta > 0)
510         //offsetY = view()->viewHeight();
511         absOffset.move(0, listHeight());
512     else if (yDelta < 0)
513         yDelta--;
514
515     // Let's attenuate the speed
516     yDelta /= speedReducer;
517
518     IntPoint scrollPoint(0, 0);
519     scrollPoint.setY(absOffset.y() + yDelta);
520     int newOffset = scrollToward(scrollPoint);
521     if (newOffset < 0) 
522         return;
523
524     m_inAutoscroll = true;
525     HTMLSelectElement* select = toHTMLSelectElement(node());
526     select->updateListBoxSelection(!select->multiple());
527     m_inAutoscroll = false;
528 }
529
530 int RenderListBox::scrollToward(const IntPoint& destination)
531 {
532     // FIXME: This doesn't work correctly with transforms.
533     FloatPoint absPos = localToAbsolute();
534     IntSize positionOffset = roundedIntSize(destination - absPos);
535
536     int rows = numVisibleItems();
537     int offset = m_indexOffset;
538     
539     if (positionOffset.height() < borderTop() + paddingTop() && scrollToRevealElementAtListIndex(offset - 1))
540         return offset - 1;
541     
542     if (positionOffset.height() > height() - paddingBottom() - borderBottom() && scrollToRevealElementAtListIndex(offset + rows))
543         return offset + rows - 1;
544     
545     return listIndexAtOffset(positionOffset);
546 }
547
548 void RenderListBox::autoscroll()
549 {
550     IntPoint pos = frame()->view()->windowToContents(frame()->eventHandler()->currentMousePosition());
551
552     int endIndex = scrollToward(pos);
553     if (endIndex >= 0) {
554         HTMLSelectElement* select = toHTMLSelectElement(node());
555         m_inAutoscroll = true;
556
557         if (!select->multiple())
558             select->setActiveSelectionAnchorIndex(endIndex);
559
560         select->setActiveSelectionEndIndex(endIndex);
561         select->updateListBoxSelection(!select->multiple());
562         m_inAutoscroll = false;
563     }
564 }
565
566 void RenderListBox::stopAutoscroll()
567 {
568     toHTMLSelectElement(node())->listBoxOnChange();
569 }
570
571 bool RenderListBox::scrollToRevealElementAtListIndex(int index)
572 {
573     if (index < 0 || index >= numItems() || listIndexIsVisible(index))
574         return false;
575
576     int newOffset;
577     if (index < m_indexOffset)
578         newOffset = index;
579     else
580         newOffset = index - numVisibleItems() + 1;
581
582     scrollToOffsetWithoutAnimation(VerticalScrollbar, newOffset);
583
584     return true;
585 }
586
587 bool RenderListBox::listIndexIsVisible(int index)
588 {    
589     return index >= m_indexOffset && index < m_indexOffset + numVisibleItems();
590 }
591
592 bool RenderListBox::scroll(ScrollDirection direction, ScrollGranularity granularity, float multiplier, Node**)
593 {
594     return ScrollableArea::scroll(direction, granularity, multiplier);
595 }
596
597 bool RenderListBox::logicalScroll(ScrollLogicalDirection direction, ScrollGranularity granularity, float multiplier, Node**)
598 {
599     return ScrollableArea::scroll(logicalToPhysical(direction, style()->isHorizontalWritingMode(), style()->isFlippedBlocksWritingMode()), granularity, multiplier);
600 }
601
602 void RenderListBox::valueChanged(unsigned listIndex)
603 {
604     HTMLSelectElement* element = toHTMLSelectElement(node());
605     element->setSelectedIndex(element->listToOptionIndex(listIndex));
606     element->dispatchFormControlChangeEvent();
607 }
608
609 int RenderListBox::scrollSize(ScrollbarOrientation orientation) const
610 {
611     return ((orientation == VerticalScrollbar) && m_vBar) ? (m_vBar->totalSize() - m_vBar->visibleSize()) : 0;
612 }
613
614 int RenderListBox::scrollPosition(Scrollbar*) const
615 {
616     return m_indexOffset;
617 }
618
619 void RenderListBox::setScrollOffset(const IntPoint& offset)
620 {
621     scrollTo(offset.y());
622 }
623
624 void RenderListBox::scrollTo(int newOffset)
625 {
626     if (newOffset == m_indexOffset)
627         return;
628
629     m_indexOffset = newOffset;
630     repaint();
631     node()->document()->eventQueue()->enqueueOrDispatchScrollEvent(node(), DocumentEventQueue::ScrollEventElementTarget);
632 }
633
634 LayoutUnit RenderListBox::itemHeight() const
635 {
636     return style()->fontMetrics().height() + rowSpacing;
637 }
638
639 int RenderListBox::verticalScrollbarWidth() const
640 {
641     return m_vBar && !m_vBar->isOverlayScrollbar() ? m_vBar->width() : 0;
642 }
643
644 // FIXME: We ignore padding in the vertical direction as far as these values are concerned, since that's
645 // how the control currently paints.
646 LayoutUnit RenderListBox::scrollWidth() const
647 {
648     // There is no horizontal scrolling allowed.
649     return clientWidth();
650 }
651
652 int RenderListBox::scrollHeight() const
653 {
654     return max(pixelSnappedClientHeight(), roundToInt(listHeight()));
655 }
656
657 int RenderListBox::scrollLeft() const
658 {
659     return 0;
660 }
661
662 void RenderListBox::setScrollLeft(int)
663 {
664 }
665
666 int RenderListBox::scrollTop() const
667 {
668     return m_indexOffset * itemHeight();
669 }
670
671 void RenderListBox::setScrollTop(int newTop)
672 {
673     // Determine an index and scroll to it.    
674     int index = newTop / itemHeight();
675     if (index < 0 || index >= numItems() || index == m_indexOffset)
676         return;
677     
678     scrollToOffsetWithoutAnimation(VerticalScrollbar, index);
679 }
680
681 bool RenderListBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const LayoutPoint& pointInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
682 {
683     if (!RenderBlock::nodeAtPoint(request, result, pointInContainer, accumulatedOffset, hitTestAction))
684         return false;
685     const Vector<HTMLElement*>& listItems = toHTMLSelectElement(node())->listItems();
686     int size = numItems();
687     LayoutPoint adjustedLocation = accumulatedOffset + location();
688
689     for (int i = 0; i < size; ++i) {
690         if (itemBoundingBoxRect(adjustedLocation, i).contains(pointInContainer)) {
691             if (Element* node = listItems[i]) {
692                 result.setInnerNode(node);
693                 if (!result.innerNonSharedNode())
694                     result.setInnerNonSharedNode(node);
695                 result.setLocalPoint(pointInContainer - toLayoutSize(adjustedLocation));
696                 break;
697             }
698         }
699     }
700
701     return true;
702 }
703
704 LayoutRect RenderListBox::controlClipRect(const LayoutPoint& additionalOffset) const
705 {
706     LayoutRect clipRect = contentBoxRect();
707     clipRect.moveBy(additionalOffset);
708     return clipRect;
709 }
710
711 bool RenderListBox::isActive() const
712 {
713     Page* page = frame()->page();
714     return page && page->focusController()->isActive();
715 }
716
717 void RenderListBox::invalidateScrollbarRect(Scrollbar* scrollbar, const IntRect& rect)
718 {
719     IntRect scrollRect = rect;
720     scrollRect.move(width() - borderRight() - scrollbar->width(), borderTop());
721     repaintRectangle(scrollRect);
722 }
723
724 IntRect RenderListBox::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntRect& scrollbarRect) const
725 {
726     RenderView* view = this->view();
727     if (!view)
728         return scrollbarRect;
729
730     IntRect rect = scrollbarRect;
731
732     int scrollbarLeft = width() - borderRight() - scrollbar->width();
733     int scrollbarTop = borderTop();
734     rect.move(scrollbarLeft, scrollbarTop);
735
736     return view->frameView()->convertFromRenderer(this, rect);
737 }
738
739 IntRect RenderListBox::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntRect& parentRect) const
740 {
741     RenderView* view = this->view();
742     if (!view)
743         return parentRect;
744
745     IntRect rect = view->frameView()->convertToRenderer(this, parentRect);
746
747     int scrollbarLeft = width() - borderRight() - scrollbar->width();
748     int scrollbarTop = borderTop();
749     rect.move(-scrollbarLeft, -scrollbarTop);
750     return rect;
751 }
752
753 IntPoint RenderListBox::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntPoint& scrollbarPoint) const
754 {
755     RenderView* view = this->view();
756     if (!view)
757         return scrollbarPoint;
758
759     IntPoint point = scrollbarPoint;
760
761     int scrollbarLeft = width() - borderRight() - scrollbar->width();
762     int scrollbarTop = borderTop();
763     point.move(scrollbarLeft, scrollbarTop);
764
765     return view->frameView()->convertFromRenderer(this, point);
766 }
767
768 IntPoint RenderListBox::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntPoint& parentPoint) const
769 {
770     RenderView* view = this->view();
771     if (!view)
772         return parentPoint;
773
774     IntPoint point = view->frameView()->convertToRenderer(this, parentPoint);
775
776     int scrollbarLeft = width() - borderRight() - scrollbar->width();
777     int scrollbarTop = borderTop();
778     point.move(-scrollbarLeft, -scrollbarTop);
779     return point;
780 }
781
782 IntSize RenderListBox::contentsSize() const
783 {
784     return IntSize(scrollWidth(), scrollHeight());
785 }
786
787 int RenderListBox::visibleHeight() const
788 {
789     return height();
790 }
791
792 int RenderListBox::visibleWidth() const
793 {
794     return width();
795 }
796
797 IntPoint RenderListBox::currentMousePosition() const
798 {
799     RenderView* view = this->view();
800     if (!view)
801         return IntPoint();
802     return view->frameView()->currentMousePosition();
803 }
804
805 bool RenderListBox::shouldSuspendScrollAnimations() const
806 {
807     RenderView* view = this->view();
808     if (!view)
809         return true;
810     return view->frameView()->shouldSuspendScrollAnimations();
811 }
812
813 bool RenderListBox::isOnActivePage() const
814 {
815     return !document()->inPageCache();
816 }
817
818 ScrollableArea* RenderListBox::enclosingScrollableArea() const
819 {
820     // FIXME: Return a RenderLayer that's scrollable.
821     return 0;
822 }
823
824 IntRect RenderListBox::scrollableAreaBoundingBox() const
825 {
826     return absoluteBoundingBoxRect();
827 }
828
829 PassRefPtr<Scrollbar> RenderListBox::createScrollbar()
830 {
831     RefPtr<Scrollbar> widget;
832     bool hasCustomScrollbarStyle = style()->hasPseudoStyle(SCROLLBAR);
833     if (hasCustomScrollbarStyle)
834         widget = RenderScrollbar::createCustomScrollbar(this, VerticalScrollbar, this);
835     else {
836         widget = Scrollbar::createNativeScrollbar(this, VerticalScrollbar, theme()->scrollbarControlSizeForPart(ListboxPart));
837         didAddVerticalScrollbar(widget.get());
838     }
839     document()->view()->addChild(widget.get());        
840     return widget.release();
841 }
842
843 void RenderListBox::destroyScrollbar()
844 {
845     if (!m_vBar)
846         return;
847
848     if (!m_vBar->isCustomScrollbar())
849         ScrollableArea::willRemoveVerticalScrollbar(m_vBar.get());
850     m_vBar->removeFromParent();
851     m_vBar->disconnectFromScrollableArea();
852     m_vBar = 0;
853 }
854
855 void RenderListBox::setHasVerticalScrollbar(bool hasScrollbar)
856 {
857     if (hasScrollbar == (m_vBar != 0))
858         return;
859
860     if (hasScrollbar)
861         m_vBar = createScrollbar();
862     else
863         destroyScrollbar();
864
865     if (m_vBar)
866         m_vBar->styleChanged();
867
868 #if ENABLE(DASHBOARD_SUPPORT)
869     // Force an update since we know the scrollbars have changed things.
870     if (document()->hasDashboardRegions())
871         document()->setDashboardRegionsDirty(true);
872 #endif
873 }
874
875 } // namespace WebCore