ColorInputType.cpp [plain text]
#include "config.h"
#if ENABLE(INPUT_TYPE_COLOR)
#include "ColorInputType.h"
#include "CSSPropertyNames.h"
#include "Chrome.h"
#include "Color.h"
#include "ElementShadow.h"
#include "HTMLDataListElement.h"
#include "HTMLDivElement.h"
#include "HTMLInputElement.h"
#include "HTMLOptionElement.h"
#include "InputTypeNames.h"
#include "MouseEvent.h"
#include "RenderObject.h"
#include "RenderView.h"
#include "ScriptController.h"
#include "ShadowRoot.h"
#include <wtf/PassOwnPtr.h>
#include <wtf/text/WTFString.h>
namespace WebCore {
using namespace HTMLNames;
static bool isValidColorString(const String& value)
{
if (value.isEmpty())
return false;
if (value[0] != '#')
return false;
if (value.length() != 7)
return false;
Color color(value);
return color.isValid() && !color.hasAlpha();
}
PassOwnPtr<InputType> ColorInputType::create(HTMLInputElement* element)
{
return adoptPtr(new ColorInputType(element));
}
ColorInputType::~ColorInputType()
{
endColorChooser();
}
void ColorInputType::attach()
{
observeFeatureIfVisible(FeatureObserver::InputTypeColor);
}
bool ColorInputType::isColorControl() const
{
return true;
}
const AtomicString& ColorInputType::formControlType() const
{
return InputTypeNames::color();
}
bool ColorInputType::supportsRequired() const
{
return false;
}
String ColorInputType::fallbackValue() const
{
return String("#000000");
}
String ColorInputType::sanitizeValue(const String& proposedValue) const
{
if (!isValidColorString(proposedValue))
return fallbackValue();
return proposedValue.lower();
}
Color ColorInputType::valueAsColor() const
{
return Color(element()->value());
}
void ColorInputType::createShadowSubtree()
{
ASSERT(element()->shadow());
Document* document = element()->document();
RefPtr<HTMLDivElement> wrapperElement = HTMLDivElement::create(document);
wrapperElement->setPseudo(AtomicString("-webkit-color-swatch-wrapper", AtomicString::ConstructFromLiteral));
RefPtr<HTMLDivElement> colorSwatch = HTMLDivElement::create(document);
colorSwatch->setPseudo(AtomicString("-webkit-color-swatch", AtomicString::ConstructFromLiteral));
wrapperElement->appendChild(colorSwatch.release(), ASSERT_NO_EXCEPTION);
element()->userAgentShadowRoot()->appendChild(wrapperElement.release(), ASSERT_NO_EXCEPTION);
updateColorSwatch();
}
void ColorInputType::setValue(const String& value, bool valueChanged, TextFieldEventBehavior eventBehavior)
{
InputType::setValue(value, valueChanged, eventBehavior);
if (!valueChanged)
return;
updateColorSwatch();
if (m_chooser)
m_chooser->setSelectedColor(valueAsColor());
}
void ColorInputType::handleDOMActivateEvent(Event* event)
{
if (element()->isDisabledOrReadOnly() || !element()->renderer())
return;
if (!ScriptController::processingUserGesture())
return;
Chrome* chrome = this->chrome();
if (chrome && !m_chooser)
m_chooser = chrome->createColorChooser(this, valueAsColor());
event->setDefaultHandled();
}
void ColorInputType::detach()
{
endColorChooser();
}
bool ColorInputType::shouldRespectListAttribute()
{
return InputType::themeSupportsDataListUI(this);
}
bool ColorInputType::typeMismatchFor(const String& value) const
{
return !isValidColorString(value);
}
void ColorInputType::didChooseColor(const Color& color)
{
if (element()->isDisabledOrReadOnly() || color == valueAsColor())
return;
element()->setValueFromRenderer(color.serialized());
updateColorSwatch();
element()->dispatchFormControlChangeEvent();
}
void ColorInputType::didEndChooser()
{
m_chooser.clear();
}
void ColorInputType::endColorChooser()
{
if (m_chooser)
m_chooser->endChooser();
}
void ColorInputType::updateColorSwatch()
{
HTMLElement* colorSwatch = shadowColorSwatch();
if (!colorSwatch)
return;
colorSwatch->setInlineStyleProperty(CSSPropertyBackgroundColor, element()->value(), false);
}
HTMLElement* ColorInputType::shadowColorSwatch() const
{
ShadowRoot* shadow = element()->userAgentShadowRoot();
return shadow ? toHTMLElement(shadow->firstChild()->firstChild()) : 0;
}
IntRect ColorInputType::elementRectRelativeToRootView() const
{
return element()->document()->view()->contentsToRootView(element()->pixelSnappedBoundingBox());
}
Color ColorInputType::currentColor()
{
return valueAsColor();
}
bool ColorInputType::shouldShowSuggestions() const
{
#if ENABLE(DATALIST_ELEMENT)
return element()->fastHasAttribute(listAttr);
#else
return false;
#endif
}
Vector<Color> ColorInputType::suggestions() const
{
Vector<Color> suggestions;
#if ENABLE(DATALIST_ELEMENT)
HTMLDataListElement* dataList = element()->dataList();
if (dataList) {
RefPtr<HTMLCollection> options = dataList->options();
for (unsigned i = 0; HTMLOptionElement* option = toHTMLOptionElement(options->item(i)); i++) {
if (!element()->isValidValue(option->value()))
continue;
Color color(option->value());
if (!color.isValid())
continue;
suggestions.append(color);
}
}
#endif
return suggestions;
}
}
#endif // ENABLE(INPUT_TYPE_COLOR)