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 }