WebCore:
[WebKit-https.git] / WebCore / rendering / RenderTheme.cpp
1 /**
2  * This file is part of the theme implementation for form controls in WebCore.
3  *
4  * Copyright (C) 2005 Apple Computer, Inc.
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Library General Public License for more details.
15  *
16  * You should have received a copy of the GNU Library General Public License
17  * along with this library; see the file COPYING.LIB.  If not, write to
18  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19  * Boston, MA 02111-1307, USA.
20  */
21
22 #include "config.h"
23 #include "RenderTheme.h"
24
25 #include "Document.h"
26 #include "GraphicsContext.h"
27 #include "HTMLInputElement.h"
28 #include "HTMLNames.h"
29 #include "render_style.h"
30 #include "RenderPopupMenu.h"
31
32 // The methods in this file are shared by all themes on every platform.
33
34 namespace WebCore {
35
36 using namespace HTMLNames;
37
38 void RenderTheme::adjustStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e)
39 {
40     // Force inline and table display styles to be inline-block (except for table- which is block)
41     if (style->display() == INLINE || style->display() == INLINE_TABLE || style->display() == TABLE_ROW_GROUP || 
42         style->display() == TABLE_HEADER_GROUP || style->display() == TABLE_FOOTER_GROUP ||
43         style->display() == TABLE_ROW || style->display() == TABLE_COLUMN_GROUP || style->display() == TABLE_COLUMN || 
44         style->display() == TABLE_CELL || style->display() == TABLE_CAPTION)
45         style->setDisplay(INLINE_BLOCK);
46     else if (style->display() == COMPACT || style->display() == RUN_IN || style->display() == LIST_ITEM || style->display() == TABLE)
47         style->setDisplay(BLOCK);
48     
49     // Call the appropriate style adjustment method based off the appearance value.
50     switch (style->appearance()) {
51         case CheckboxAppearance:
52             return adjustCheckboxStyle(selector, style, e);
53         case RadioAppearance:
54             return adjustRadioStyle(selector, style, e);
55         case PushButtonAppearance:
56         case SquareButtonAppearance:
57         case ButtonAppearance:
58             return adjustButtonStyle(selector, style, e);
59         case TextFieldAppearance:
60             return adjustTextFieldStyle(selector, style, e);
61         case TextAreaAppearance:
62             return adjustTextAreaStyle(selector, style, e);
63         case MenulistAppearance:
64             return adjustMenuListStyle(selector, style, e);
65         default:
66             break;
67     }
68 }
69
70 bool RenderTheme::paint(RenderObject* o, const RenderObject::PaintInfo& i, const IntRect& r)
71 {
72     // If painting is disabled, but we aren't updating control tints, then just bail.
73     // If we are updating control tints, just schedule a repaint if the theme supports tinting
74     // for that control.
75     if (i.p->updatingControlTints()) {
76         if (controlSupportsTints(o))
77             o->repaint();
78         return false;
79     }
80     if (i.p->paintingDisabled())
81         return false;
82         
83     // Call the appropriate paint method based off the appearance value.
84     switch (o->style()->appearance()) {
85         case CheckboxAppearance:
86             return paintCheckbox(o, i, r);
87         case RadioAppearance:
88             return paintRadio(o, i, r);
89         case PushButtonAppearance:
90         case SquareButtonAppearance:
91         case ButtonAppearance:
92             return paintButton(o, i, r);
93         case MenulistAppearance:
94             return paintMenuList(o, i, r);
95         case TextFieldAppearance:
96         case TextAreaAppearance:
97             return true;
98         default:
99             break;
100     }
101     
102     return true; // We don't support the appearance, so let the normal background/border paint.
103 }
104
105 bool RenderTheme::paintBorderOnly(RenderObject* o, const RenderObject::PaintInfo& i, const IntRect& r)
106 {
107     if (i.p->paintingDisabled())
108         return false;
109         
110     // Call the appropriate paint method based off the appearance value.
111     switch (o->style()->appearance()) {
112         case TextFieldAppearance:
113             return paintTextField(o, i, r);
114         case TextAreaAppearance:
115             return paintTextArea(o, i, r);
116         case CheckboxAppearance:
117         case RadioAppearance:
118         case PushButtonAppearance:
119         case SquareButtonAppearance:
120         case ButtonAppearance:
121         case MenulistAppearance:
122         default:
123             break;
124     }
125     
126     return false;
127 }
128
129 Color RenderTheme::activeSelectionBackgroundColor() const
130 {
131     static Color activeSelectionColor;
132     if (!activeSelectionColor.isValid())
133         activeSelectionColor = platformActiveSelectionBackgroundColor().blendWithWhite();
134     return activeSelectionColor;
135 }
136
137 Color RenderTheme::inactiveSelectionBackgroundColor() const
138 {
139     static Color inactiveSelectionColor;
140     if (!inactiveSelectionColor.isValid())
141         inactiveSelectionColor = platformInactiveSelectionBackgroundColor().blendWithWhite();
142     return inactiveSelectionColor;
143 }
144
145 Color RenderTheme::platformActiveSelectionBackgroundColor() const
146 {
147     // Use a blue color by default if the platform theme doesn't define anything.
148     return Color(0, 0, 255);
149 }
150     
151 Color RenderTheme::platformInactiveSelectionBackgroundColor() const
152 {
153     // Use a grey color by default if the platform theme doesn't define anything.
154     return Color(128, 128, 128);
155 }
156    
157 Color RenderTheme::platformActiveSelectionForegroundColor() const
158 {
159     return Color();
160 }
161     
162 Color RenderTheme::platformInactiveSelectionForegroundColor() const
163 {
164     return Color();
165 }
166
167 short RenderTheme::baselinePosition(const RenderObject* o) const
168 {
169     return o->height() + o->marginTop();
170 }
171
172 bool RenderTheme::isControlContainer(EAppearance appearance) const
173 {
174     // There are more leaves than this, but we'll patch this function as we add support for
175     // more controls.
176     return appearance != CheckboxAppearance && appearance != RadioAppearance;
177 }
178
179 bool RenderTheme::isControlStyled(const RenderStyle* style, const BorderData& border, const BackgroundLayer& background,
180                                   const Color& backgroundColor) const
181 {
182     switch (style->appearance()) {
183         case PushButtonAppearance:
184         case SquareButtonAppearance:
185         case ButtonAppearance:
186         case MenulistAppearance:
187         case TextFieldAppearance:
188         case TextAreaAppearance: {
189             // Test the style to see if the UA border and background match.
190             return (style->border() != border ||
191                     *style->backgroundLayers() != background ||
192                     style->backgroundColor() != backgroundColor);
193         }
194         default:
195             return false;
196     }
197     
198     return false;
199 }
200
201 bool RenderTheme::supportsFocusRing(const RenderStyle* style) const
202 {
203     return (style->hasAppearance() && style->appearance() != TextFieldAppearance && style->appearance() != TextAreaAppearance);
204 }
205
206 bool RenderTheme::stateChanged(RenderObject* o, ControlState state) const
207 {
208     // Default implementation assumes the controls dont respond to changes in :hover state
209     if (state == HoverState && !supportsHover(o->style()))
210         return false;
211         
212     // Assume pressed state is only responded to if the control is enabled.
213     if (state == PressedState && !isEnabled(o))
214         return false;
215     
216     // Repaint the control.
217     o->repaint();
218     return true;
219 }
220
221 bool RenderTheme::isChecked(const RenderObject* o) const
222 {
223     if (!o->element())
224         return false;
225     return o->element()->isChecked();
226 }
227
228 bool RenderTheme::isIndeterminate(const RenderObject* o) const
229 {
230     if (!o->element())
231         return false;
232     return o->element()->isIndeterminate();
233 }
234
235 bool RenderTheme::isEnabled(const RenderObject* o) const
236 {
237     if (!o->element())
238         return true;
239     return o->element()->isEnabled();
240 }
241
242 bool RenderTheme::isFocused(const RenderObject* o) const
243 {
244     if (!o->element())
245         return false;
246     return o->element() == o->element()->document()->focusNode();
247 }
248
249 bool RenderTheme::isPressed(const RenderObject* o) const
250 {
251     if (!o->element())
252         return false;
253     return o->element()->active();
254 }
255
256 bool RenderTheme::isReadOnlyControl(const RenderObject* o) const
257 {
258     if (!o->element())
259         return false;
260     return o->element()->isReadOnlyControl();
261 }
262
263 bool RenderTheme::isHovered(const RenderObject* o) const
264 {
265     if (!o->element())
266         return false;
267     return o->element()->hovered();
268 }
269
270 void RenderTheme::adjustCheckboxStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e) const
271 {
272     // A summary of the rules for checkbox designed to match WinIE:
273     // width/height - honored (WinIE actually scales its control for small widths, but lets it overflow for small heights.)
274     // font-size - not honored (control has no text), but we use it to decide which control size to use.
275     setCheckboxSize(style);
276     
277     // padding - not honored by WinIE, needs to be removed.
278     style->resetPadding();
279     
280     // border - honored by WinIE, but looks terrible (just paints in the control box and turns off the Windows XP theme)
281     // for now, we will not honor it.
282     style->resetBorder();
283 }
284
285 void RenderTheme::adjustRadioStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e) const
286 {
287     // A summary of the rules for checkbox designed to match WinIE:
288     // width/height - honored (WinIE actually scales its control for small widths, but lets it overflow for small heights.)
289     // font-size - not honored (control has no text), but we use it to decide which control size to use.
290     setRadioSize(style);
291     
292     // padding - not honored by WinIE, needs to be removed.
293     style->resetPadding();
294     
295     // border - honored by WinIE, but looks terrible (just paints in the control box and turns off the Windows XP theme)
296     // for now, we will not honor it.
297     style->resetBorder();
298 }
299
300 void RenderTheme::adjustButtonStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e) const
301 {
302     // Most platforms will completely honor all CSS, and so we have no need to adjust the style
303     // at all by default.  We will still allow the theme a crack at setting up a desired vertical size.
304     setButtonSize(style);
305 }
306
307 void RenderTheme::adjustTextFieldStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e) const
308 {
309 }
310
311 void RenderTheme::adjustTextAreaStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e) const
312 {
313 }
314
315 void RenderTheme::adjustMenuListStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e) const
316 {
317 }
318
319 }