Use a 1-byte enum class for TextDirection
[WebKit-https.git] / Source / WebCore / html / shadow / TextControlInnerElements.cpp
1 /*
2  * Copyright (C) 2006-2018 Apple Inc. All rights reserved.
3  * Copyright (C) 2010 Google Inc. All rights reserved.
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  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 #include "config.h"
28 #include "TextControlInnerElements.h"
29
30 #include "CSSPrimitiveValue.h"
31 #include "CSSToLengthConversionData.h"
32 #include "Document.h"
33 #include "EventNames.h"
34 #include "Frame.h"
35 #include "HTMLInputElement.h"
36 #include "HTMLNames.h"
37 #include "LocalizedStrings.h"
38 #include "MouseEvent.h"
39 #include "PlatformMouseEvent.h"
40 #include "RenderSearchField.h"
41 #include "RenderTextControl.h"
42 #include "RenderView.h"
43 #include "ScriptController.h"
44 #include "ShadowRoot.h"
45 #include "StyleResolver.h"
46 #include "TextEvent.h"
47 #include "TextEventInputType.h"
48 #include <wtf/IsoMallocInlines.h>
49 #include <wtf/Ref.h>
50
51 namespace WebCore {
52
53 WTF_MAKE_ISO_ALLOCATED_IMPL(TextControlInnerContainer);
54 WTF_MAKE_ISO_ALLOCATED_IMPL(TextControlInnerElement);
55 WTF_MAKE_ISO_ALLOCATED_IMPL(TextControlInnerTextElement);
56 WTF_MAKE_ISO_ALLOCATED_IMPL(TextControlPlaceholderElement);
57 WTF_MAKE_ISO_ALLOCATED_IMPL(SearchFieldResultsButtonElement);
58 WTF_MAKE_ISO_ALLOCATED_IMPL(SearchFieldCancelButtonElement);
59
60 using namespace HTMLNames;
61
62 TextControlInnerContainer::TextControlInnerContainer(Document& document)
63     : HTMLDivElement(divTag, document)
64 {
65     setHasCustomStyleResolveCallbacks();
66 }
67
68 Ref<TextControlInnerContainer> TextControlInnerContainer::create(Document& document)
69 {
70     return adoptRef(*new TextControlInnerContainer(document));
71 }
72     
73 RenderPtr<RenderElement> TextControlInnerContainer::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
74 {
75     return createRenderer<RenderTextControlInnerContainer>(*this, WTFMove(style));
76 }
77
78 static inline bool isStrongPasswordTextField(const Element* element)
79 {
80     return is<HTMLInputElement>(element) && downcast<HTMLInputElement>(element)->hasAutoFillStrongPasswordButton();
81 }
82
83 std::optional<ElementStyle> TextControlInnerContainer::resolveCustomStyle(const RenderStyle& parentStyle, const RenderStyle*)
84 {
85     auto elementStyle = resolveStyle(&parentStyle);
86     if (isStrongPasswordTextField(shadowHost())) {
87         elementStyle.renderStyle->setFlexWrap(FlexWrap::Wrap);
88         elementStyle.renderStyle->setOverflowX(Overflow::Hidden);
89         elementStyle.renderStyle->setOverflowY(Overflow::Hidden);
90     }
91     return WTFMove(elementStyle);
92 }
93
94 TextControlInnerElement::TextControlInnerElement(Document& document)
95     : HTMLDivElement(divTag, document)
96 {
97     setHasCustomStyleResolveCallbacks();
98 }
99
100 Ref<TextControlInnerElement> TextControlInnerElement::create(Document& document)
101 {
102     return adoptRef(*new TextControlInnerElement(document));
103 }
104
105 std::optional<ElementStyle> TextControlInnerElement::resolveCustomStyle(const RenderStyle&, const RenderStyle* shadowHostStyle)
106 {
107     auto newStyle = RenderStyle::createPtr();
108     newStyle->inheritFrom(*shadowHostStyle);
109     newStyle->setFlexGrow(1);
110     newStyle->setMinWidth(Length { 0, Fixed }); // Needed for correct shrinking.
111     newStyle->setDisplay(DisplayType::Block);
112     newStyle->setDirection(TextDirection::LTR);
113     // We don't want the shadow DOM to be editable, so we set this block to read-only in case the input itself is editable.
114     newStyle->setUserModify(UserModify::ReadOnly);
115
116     if (isStrongPasswordTextField(shadowHost())) {
117         newStyle->setFlexShrink(0);
118         newStyle->setTextOverflow(TextOverflow::Clip);
119         newStyle->setOverflowX(Overflow::Hidden);
120         newStyle->setOverflowY(Overflow::Hidden);
121
122         // Set "flex-basis: 1em". Note that CSSPrimitiveValue::computeLengthInt() only needs the element's
123         // style to calculate em lengths. Since the element might not be in a document, just pass nullptr
124         // for the root element style and the render view.
125         RefPtr<CSSPrimitiveValue> emSize = CSSPrimitiveValue::create(1, CSSPrimitiveValue::CSS_EMS);
126         int pixels = emSize->computeLength<int>(CSSToLengthConversionData { newStyle.get(), nullptr, nullptr, 1.0, false });
127         newStyle->setFlexBasis(Length { pixels, Fixed });
128     }
129
130     return ElementStyle { WTFMove(newStyle) };
131 }
132
133 // MARK: TextControlInnerTextElement
134
135 inline TextControlInnerTextElement::TextControlInnerTextElement(Document& document)
136     : HTMLDivElement(divTag, document)
137 {
138     setHasCustomStyleResolveCallbacks();
139 }
140
141 Ref<TextControlInnerTextElement> TextControlInnerTextElement::create(Document& document)
142 {
143     return adoptRef(*new TextControlInnerTextElement(document));
144 }
145
146 void TextControlInnerTextElement::defaultEventHandler(Event& event)
147 {
148     // FIXME: In the future, we should add a way to have default event listeners.
149     // Then we would add one to the text field's inner div, and we wouldn't need this subclass.
150     // Or possibly we could just use a normal event listener.
151     if (event.isBeforeTextInsertedEvent() || event.type() == eventNames().webkitEditableContentChangedEvent) {
152         RefPtr<Element> shadowAncestor = shadowHost();
153         // A TextControlInnerTextElement can have no host if its been detached,
154         // but kept alive by an EditCommand. In this case, an undo/redo can
155         // cause events to be sent to the TextControlInnerTextElement. To
156         // prevent an infinite loop, we must check for this case before sending
157         // the event up the chain.
158         if (shadowAncestor)
159             shadowAncestor->defaultEventHandler(event);
160     }
161     if (!event.defaultHandled())
162         HTMLDivElement::defaultEventHandler(event);
163 }
164
165 RenderPtr<RenderElement> TextControlInnerTextElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
166 {
167     return createRenderer<RenderTextControlInnerBlock>(*this, WTFMove(style));
168 }
169
170 RenderTextControlInnerBlock* TextControlInnerTextElement::renderer() const
171 {
172     return downcast<RenderTextControlInnerBlock>(HTMLDivElement::renderer());
173 }
174
175 std::optional<ElementStyle> TextControlInnerTextElement::resolveCustomStyle(const RenderStyle&, const RenderStyle* shadowHostStyle)
176 {
177     auto style = downcast<HTMLTextFormControlElement>(*shadowHost()).createInnerTextStyle(*shadowHostStyle);
178     return ElementStyle(std::make_unique<RenderStyle>(WTFMove(style)));
179 }
180
181 // MARK: TextControlPlaceholderElement
182
183 inline TextControlPlaceholderElement::TextControlPlaceholderElement(Document& document)
184     : HTMLDivElement(divTag, document)
185 {
186     setPseudo(AtomicString("placeholder", AtomicString::ConstructFromLiteral));
187     setHasCustomStyleResolveCallbacks();
188 }
189
190 Ref<TextControlPlaceholderElement> TextControlPlaceholderElement::create(Document& document)
191 {
192     return adoptRef(*new TextControlPlaceholderElement(document));
193 }
194
195 std::optional<ElementStyle> TextControlPlaceholderElement::resolveCustomStyle(const RenderStyle& parentStyle, const RenderStyle* shadowHostStyle)
196 {
197     auto style = resolveStyle(&parentStyle);
198
199     auto& controlElement = downcast<HTMLTextFormControlElement>(*containingShadowRoot()->host());
200     style.renderStyle->setDisplay(controlElement.isPlaceholderVisible() ? DisplayType::Block : DisplayType::None);
201
202     if (is<HTMLInputElement>(controlElement)) {
203         auto& inputElement = downcast<HTMLInputElement>(controlElement);
204         style.renderStyle->setTextOverflow(inputElement.shouldTruncateText(*shadowHostStyle) ? TextOverflow::Ellipsis : TextOverflow::Clip);
205     }
206     return WTFMove(style);
207 }
208
209 // MARK: SearchFieldResultsButtonElement
210
211 inline SearchFieldResultsButtonElement::SearchFieldResultsButtonElement(Document& document)
212     : HTMLDivElement(divTag, document)
213 {
214 }
215
216 Ref<SearchFieldResultsButtonElement> SearchFieldResultsButtonElement::create(Document& document)
217 {
218     return adoptRef(*new SearchFieldResultsButtonElement(document));
219 }
220
221 void SearchFieldResultsButtonElement::defaultEventHandler(Event& event)
222 {
223     // On mousedown, bring up a menu, if needed
224     auto input = makeRefPtr(downcast<HTMLInputElement>(shadowHost()));
225     if (input && event.type() == eventNames().mousedownEvent && is<MouseEvent>(event) && downcast<MouseEvent>(event).button() == LeftButton) {
226         input->focus();
227         input->select();
228 #if !PLATFORM(IOS)
229         if (auto* renderer = input->renderer()) {
230             auto& searchFieldRenderer = downcast<RenderSearchField>(*renderer);
231             if (searchFieldRenderer.popupIsVisible())
232                 searchFieldRenderer.hidePopup();
233             else if (input->maxResults() > 0)
234                 searchFieldRenderer.showPopup();
235         }
236 #endif
237         event.setDefaultHandled();
238     }
239
240     if (!event.defaultHandled())
241         HTMLDivElement::defaultEventHandler(event);
242 }
243
244 #if !PLATFORM(IOS)
245 bool SearchFieldResultsButtonElement::willRespondToMouseClickEvents()
246 {
247     return true;
248 }
249 #endif
250
251 // MARK: SearchFieldCancelButtonElement
252
253 inline SearchFieldCancelButtonElement::SearchFieldCancelButtonElement(Document& document)
254     : HTMLDivElement(divTag, document)
255 {
256     setPseudo(AtomicString("-webkit-search-cancel-button", AtomicString::ConstructFromLiteral));
257 #if !PLATFORM(IOS)
258     setAttributeWithoutSynchronization(aria_labelAttr, AXSearchFieldCancelButtonText());
259 #endif
260     setAttributeWithoutSynchronization(roleAttr, AtomicString("button", AtomicString::ConstructFromLiteral));
261 }
262
263 Ref<SearchFieldCancelButtonElement> SearchFieldCancelButtonElement::create(Document& document)
264 {
265     return adoptRef(*new SearchFieldCancelButtonElement(document));
266 }
267
268 void SearchFieldCancelButtonElement::defaultEventHandler(Event& event)
269 {
270     RefPtr<HTMLInputElement> input(downcast<HTMLInputElement>(shadowHost()));
271     if (!input || input->isDisabledOrReadOnly()) {
272         if (!event.defaultHandled())
273             HTMLDivElement::defaultEventHandler(event);
274         return;
275     }
276
277     if (event.type() == eventNames().mousedownEvent && is<MouseEvent>(event) && downcast<MouseEvent>(event).button() == LeftButton) {
278         input->focus();
279         input->select();
280         event.setDefaultHandled();
281     }
282
283     if (event.type() == eventNames().clickEvent) {
284         input->setValueForUser(emptyString());
285         input->onSearch();
286         event.setDefaultHandled();
287     }
288
289     if (!event.defaultHandled())
290         HTMLDivElement::defaultEventHandler(event);
291 }
292
293 #if !PLATFORM(IOS)
294 bool SearchFieldCancelButtonElement::willRespondToMouseClickEvents()
295 {
296     const RefPtr<HTMLInputElement> input = downcast<HTMLInputElement>(shadowHost());
297     if (input && !input->isDisabledOrReadOnly())
298         return true;
299
300     return HTMLDivElement::willRespondToMouseClickEvents();
301 }
302 #endif
303
304 }