blob: 6d8f236a32ad791af1fa4712f000bffca22e6d0d [file] [log] [blame]
/*
* Copyright (C) 2017 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/
WI.SpreadsheetCSSStyleDeclarationSection = class SpreadsheetCSSStyleDeclarationSection extends WI.View
{
constructor(delegate, style)
{
console.assert(style instanceof WI.CSSStyleDeclaration, style);
let element = document.createElement("section");
element.classList.add("spreadsheet-css-declaration");
super(element);
this._delegate = delegate || null;
this._style = style;
this._propertiesEditor = null;
this._selectorElements = [];
this._groupingElements = [];
this._filterText = null;
this._shouldFocusSelectorElement = false;
this._wasEditing = false;
this._isMousePressed = false;
this._mouseDownIndex = NaN;
this._mouseDownPoint = null;
this._boundHandleWindowMouseMove = null;
}
// Public
get style() { return this._style; }
get editable()
{
return this._style.editable;
}
initialLayout()
{
super.initialLayout();
if (WI.settings.experimentalEnableStylesIcons.value) {
let iconClassName = null;
switch (this._style.type) {
case WI.CSSStyleDeclaration.Type.Rule:
console.assert(this._style.ownerRule);
if (this._style.inherited) {
iconClassName = "inherited-style-rule-icon";
break;
}
switch (this._style.ownerRule.type) {
case WI.CSSStyleSheet.Type.Author:
iconClassName = "author-style-rule-icon";
break;
case WI.CSSStyleSheet.Type.User:
iconClassName = "user-style-rule-icon";
break;
case WI.CSSStyleSheet.Type.UserAgent:
iconClassName = "user-agent-style-rule-icon";
break;
case WI.CSSStyleSheet.Type.Inspector:
iconClassName = "inspector-style-rule-icon";
break;
}
break;
case WI.CSSStyleDeclaration.Type.Inline:
case WI.CSSStyleDeclaration.Type.Attribute:
if (this._style.inherited)
iconClassName = "inherited-element-style-rule-icon";
else
iconClassName = WI.DOMTreeElementPathComponent.DOMElementIconStyleClassName;
break;
}
console.assert(iconClassName);
this._element.classList.add("has-icon", iconClassName);
}
let groupings = this._style.groupings.filter((grouping) => grouping.text !== "all");
if (groupings.length) {
let groupingsElement = this.element.appendChild(document.createElement("div"));
groupingsElement.classList.add("header-groupings");
let currentGroupingType = null;
let groupingTypeElement = null;
this._groupingElements = groupings.map((grouping) => {
if (grouping.type !== currentGroupingType) {
groupingTypeElement = groupingsElement.appendChild(document.createElement("div"));
groupingTypeElement.classList.add("grouping");
groupingTypeElement.textContent = grouping.prefix + " ";
currentGroupingType = grouping.type;
} else
groupingTypeElement.append(", ");
let span = groupingTypeElement.appendChild(document.createElement("span"));
span.textContent = grouping.text;
return span;
});
}
this._headerElement = this._element.appendChild(document.createElement("div"));
this._headerElement.classList.add("header");
this._styleOriginView = new WI.StyleOriginView();
this._headerElement.append(this._styleOriginView.element);
this._selectorElement = document.createElement("span");
this._selectorElement.classList.add("selector");
this._selectorElement.addEventListener("mouseenter", this._highlightNodesWithSelector.bind(this));
this._selectorElement.addEventListener("mouseleave", this._hideDOMNodeHighlight.bind(this));
this._headerElement.append(this._selectorElement);
this._openBrace = document.createElement("span");
this._openBrace.classList.add("open-brace");
this._openBrace.textContent = " {";
this._headerElement.append(this._openBrace);
if (this._style.selectorEditable) {
this._selectorTextField = new WI.SpreadsheetSelectorField(this, this._selectorElement);
this._selectorTextField.addEventListener(WI.SpreadsheetSelectorField.Event.StartedEditing, (event) => {
this._headerElement.classList.add("editing-selector");
});
this._selectorTextField.addEventListener(WI.SpreadsheetSelectorField.Event.StoppedEditing, (event) => {
this._headerElement.classList.remove("editing-selector");
});
this._selectorElement.tabIndex = 0;
}
this._propertiesEditor = new WI.SpreadsheetCSSStyleDeclarationEditor(this, this._style);
this._propertiesEditor.element.classList.add("properties");
this._propertiesEditor.addEventListener(WI.SpreadsheetCSSStyleDeclarationEditor.Event.FilterApplied, this._handleEditorFilterApplied, this);
this._closeBrace = document.createElement("span");
this._closeBrace.classList.add("close-brace");
this._closeBrace.textContent = "}";
this.addSubview(this._propertiesEditor);
this._propertiesEditor.needsLayout();
this._element.append(this._closeBrace);
if (!this._style.editable)
this._element.classList.add("locked");
else if (!this._style.ownerRule)
this._element.classList.add("selector-locked");
this.element.addEventListener("mousedown", this._handleMouseDown.bind(this));
if (this._style.editable) {
this.element.addEventListener("click", this._handleClick.bind(this));
new WI.KeyboardShortcut(WI.KeyboardShortcut.Modifier.CommandOrControl, "S", this._save.bind(this), this._element);
new WI.KeyboardShortcut(WI.KeyboardShortcut.Modifier.CommandOrControl | WI.KeyboardShortcut.Modifier.Shift, "S", this._save.bind(this), this._element);
}
}
layout()
{
super.layout();
this._styleOriginView.update(this._style);
this._renderSelector();
if (this._shouldFocusSelectorElement)
this.startEditingRuleSelector();
}
hidden()
{
this._propertiesEditor.hidden();
}
startEditingRuleSelector()
{
if (!this._selectorElement) {
this._shouldFocusSelectorElement = true;
return;
}
this._shouldFocusSelectorElement = false;
if (this._style.selectorEditable)
this._selectorTextField.startEditing();
else
this._propertiesEditor.startEditingFirstProperty();
}
highlightProperty(property)
{
// When navigating from the Computed panel to the Styles panel, the latter
// could be empty. Layout all properties so they can be highlighted.
if (!this.didInitialLayout)
this.updateLayout();
if (this._propertiesEditor.highlightProperty(property)) {
this._element.scrollIntoView();
return true;
}
return false;
}
// SpreadsheetSelectorField delegate
spreadsheetSelectorFieldDidCommit(changed)
{
let selectorText = this._selectorElement.textContent.trim();
if (selectorText && changed) {
this.dispatchEventToListeners(WI.SpreadsheetCSSStyleDeclarationSection.Event.SelectorWillChange);
this._style.ownerRule.singleFireEventListener(WI.CSSRule.Event.SelectorChanged, this._renderSelector, this);
this._style.ownerRule.selectorText = selectorText;
} else
this._discardSelectorChange();
}
spreadsheetSelectorFieldWillNavigate(direction)
{
console.assert(direction);
if (direction === "forward")
this._propertiesEditor.startEditingFirstProperty();
else if (direction === "backward") {
if (this._delegate.spreadsheetCSSStyleDeclarationSectionStartEditingAdjacentRule) {
const delta = -1;
this._delegate.spreadsheetCSSStyleDeclarationSectionStartEditingAdjacentRule(this, delta);
} else
this._propertiesEditor.startEditingLastProperty();
}
}
spreadsheetSelectorFieldDidDiscard()
{
this._discardSelectorChange();
}
// SpreadsheetCSSStyleDeclarationEditor delegate
spreadsheetCSSStyleDeclarationEditorStartEditingRuleSelector()
{
this.startEditingRuleSelector();
}
spreadsheetCSSStyleDeclarationEditorStartEditingAdjacentRule(propertiesEditor, delta)
{
if (!this._delegate)
return;
if (this._delegate.spreadsheetCSSStyleDeclarationSectionStartEditingAdjacentRule)
this._delegate.spreadsheetCSSStyleDeclarationSectionStartEditingAdjacentRule(this, delta);
}
spreadsheetCSSStyleDeclarationEditorPropertyBlur(event, property)
{
if (!this._isMousePressed)
this._propertiesEditor.deselectProperties();
}
spreadsheetCSSStyleDeclarationEditorPropertyMouseEnter(event, property)
{
if (this._isMousePressed) {
let index = parseInt(property.element.dataset.propertyIndex);
this._propertiesEditor.selectProperties(this._mouseDownIndex, index);
}
}
spreadsheetCSSStyleDeclarationEditorSelectProperty(property)
{
if (this._delegate && this._delegate.spreadsheetCSSStyleDeclarationSectionSelectProperty)
this._delegate.spreadsheetCSSStyleDeclarationSectionSelectProperty(property);
}
applyFilter(filterText)
{
this._filterText = filterText;
if (!this.didInitialLayout)
return;
this._element.classList.remove(WI.GeneralStyleDetailsSidebarPanel.NoFilterMatchInSectionClassName);
this._propertiesEditor.applyFilter(this._filterText);
}
// Private
_discardSelectorChange()
{
// Re-render selector for syntax highlighting.
this._renderSelector();
}
_renderSelector()
{
this._selectorElement.removeChildren();
this._selectorElements = [];
let appendSelector = (selector, matched) => {
console.assert(selector instanceof WI.CSSSelector);
let selectorElement = this._selectorElement.appendChild(document.createElement("span"));
selectorElement.textContent = selector.text;
if (matched)
selectorElement.classList.add(WI.SpreadsheetCSSStyleDeclarationSection.MatchedSelectorElementStyleClassName);
if (selector.specificity) {
let specificity = selector.specificity.map((number) => number.toLocaleString());
let tooltip = WI.UIString("Specificity: (%d, %d, %d)").format(...specificity);
if (selector.dynamic) {
tooltip += "\n";
if (this._style.inherited)
tooltip += WI.UIString("Dynamically calculated for the parent element");
else
tooltip += WI.UIString("Dynamically calculated for the selected element");
}
selectorElement.title = tooltip;
} else if (selector.dynamic) {
let tooltip = WI.UIString("Specificity: No value for selected element");
tooltip += "\n";
tooltip += WI.UIString("Dynamically calculated for the selected element and did not match");
selectorElement.title = tooltip;
}
this._selectorElements.push(selectorElement);
};
let appendSelectorTextKnownToMatch = (selectorText) => {
let selectorElement = this._selectorElement.appendChild(document.createElement("span"));
selectorElement.textContent = selectorText;
selectorElement.classList.add(WI.SpreadsheetCSSStyleDeclarationSection.MatchedSelectorElementStyleClassName);
};
if (WI.settings.experimentalEnableStylesIcons.value) {
if (!this._iconElement) {
this._iconElement = document.createElement("img");
this._iconElement.classList.add("icon");
WI.addMouseDownContextMenuHandlers(this._iconElement, this._populateIconElementContextMenu.bind(this));
}
this._selectorElement.appendChild(this._iconElement);
}
switch (this._style.type) {
case WI.CSSStyleDeclaration.Type.Rule:
console.assert(this._style.ownerRule);
var hasMatchingPseudoSelector = false;
var selectors = this._style.ownerRule.selectors;
if (selectors.length) {
for (let i = 0; i < selectors.length; ++i) {
let matched = this._style.ownerRule.matchedSelectorIndices.includes(i);
if (matched && selectors[i].isPseudoSelector())
hasMatchingPseudoSelector = true;
appendSelector(selectors[i], matched);
if (i < selectors.length - 1)
this._selectorElement.append(", ");
}
} else
appendSelectorTextKnownToMatch(this._style.ownerRule.selectorText);
this._element.classList.toggle("pseudo-selector", hasMatchingPseudoSelector);
break;
case WI.CSSStyleDeclaration.Type.Inline: {
this._selectorElement.classList.add("style-attribute");
let wrapper = this._selectorElement.appendChild(document.createElement("span"));
wrapper.textContent = WI.UIString("Style Attribute", "CSS properties defined via HTML style attribute");
break;
}
case WI.CSSStyleDeclaration.Type.Attribute:
appendSelectorTextKnownToMatch(this._style.node.displayName);
break;
}
if (this._filterText)
this.applyFilter(this._filterText);
}
_save(event)
{
event.stop();
if (this._style.type !== WI.CSSStyleDeclaration.Type.Rule) {
// FIXME: Can't save CSS inside <style></style> <https://webkit.org/b/150357>
InspectorFrontendHost.beep();
return;
}
console.assert(this._style.ownerRule instanceof WI.CSSRule);
console.assert(this._style.ownerRule.sourceCodeLocation instanceof WI.SourceCodeLocation);
let sourceCode = this._style.ownerRule.sourceCodeLocation.sourceCode;
if (sourceCode.type !== WI.Resource.Type.StyleSheet) {
// FIXME: Can't save CSS inside style="" <https://webkit.org/b/150357>
InspectorFrontendHost.beep();
return;
}
let url;
if (sourceCode.urlComponents.scheme === "data") {
let mainResource = WI.networkManager.mainFrame.mainResource;
if (mainResource.urlComponents.lastPathComponent.endsWith(".html"))
url = mainResource.url.replace(/\.html$/, "-data.css");
else {
let pathDirectory = mainResource.url.slice(0, -mainResource.urlComponents.lastPathComponent.length);
url = pathDirectory + "data.css";
}
} else
url = sourceCode.url;
const saveAs = event.shiftKey;
WI.FileUtilities.save({url: url, content: sourceCode.content}, saveAs);
}
_handleMouseDown(event)
{
if (event.button !== 0)
return;
this._wasEditing = this._propertiesEditor.editing || document.activeElement === this._selectorElement;
let propertyElement = event.target.closest(".property");
if (!propertyElement)
return;
this._isMousePressed = true;
// Disable text selection on mousemove.
event.preventDefault();
// Canceling mousedown event prevents blur event from firing on the previously focused element.
if (this._wasEditing && document.activeElement)
document.activeElement.blur();
// Prevent name/value fields from editing when properties selected.
window.addEventListener("click", this._handleWindowClick.bind(this), {capture: true, once: true});
let propertyIndex = parseInt(propertyElement.dataset.propertyIndex);
if (event.shiftKey && this._propertiesEditor.hasSelectedProperties())
this._propertiesEditor.extendSelectedProperties(propertyIndex);
else {
this._propertiesEditor.deselectProperties();
this._mouseDownPoint = WI.Point.fromEvent(event);
if (!this._boundHandleWindowMouseMove)
this._boundHandleWindowMouseMove = this._handleWindowMouseMove.bind(this);
window.addEventListener("mousemove", this._boundHandleWindowMouseMove);
}
if (propertyElement.parentNode) {
this._mouseDownIndex = propertyIndex;
this._element.classList.add("selecting");
} else
this._stopSelection();
}
_populateIconElementContextMenu(contextMenu)
{
contextMenu.appendItem(WI.UIString("Copy Rule"), () => {
InspectorFrontendHost.copyText(this._style.generateCSSRuleString());
});
if (this._style.editable && this._style.properties.length) {
let shouldDisable = this._style.properties.some((property) => property.enabled);
contextMenu.appendItem(shouldDisable ? WI.UIString("Disable Rule") : WI.UIString("Enable Rule"), () => {
for (let property of this._style.properties)
property.commentOut(shouldDisable);
});
}
if (!this._style.inherited) {
let generateSelector = () => {
if (this._style.type === WI.CSSStyleDeclaration.Type.Attribute)
return this._style.node.displayName;
return this._style.selectorText;
};
let createNewRule = (selector, text) => {
if (this._delegate && this._delegate.spreadsheetCSSStyleDeclarationSectionAddNewRule)
this._delegate.spreadsheetCSSStyleDeclarationSectionAddNewRule(this, selector, text);
else
this._style.nodeStyles.addRule(selector, text);
};
contextMenu.appendSeparator();
contextMenu.appendItem(WI.UIString("Duplicate Selector"), () => {
createNewRule(generateSelector());
});
if (!WI.CSSManager.PseudoElementNames.some((className) => this._style.selectorText.includes(":" + className))) {
let addPseudoRule = (pseudoSelector, text) => {
let selector = null;
if (this._style.ownerRule)
selector = this._style.ownerRule.selectors.map((selector) => selector.text + pseudoSelector).join(", ");
else
selector = generateSelector() + pseudoSelector;
createNewRule(selector, text);
};
if (WI.CSSManager.ForceablePseudoClasses.every((className) => !this._style.selectorText.includes(":" + className))) {
contextMenu.appendSeparator();
for (let pseudoClass of WI.CSSManager.ForceablePseudoClasses) {
if (pseudoClass === "visited" && this._style.node.nodeName() !== "A")
continue;
let pseudoClassSelector = ":" + pseudoClass;
contextMenu.appendItem(WI.UIString("Add %s Rule").format(pseudoClassSelector), () => {
this._style.node.setPseudoClassEnabled(pseudoClass, true);
addPseudoRule(pseudoClassSelector);
});
}
}
if (this._style.type === WI.CSSStyleDeclaration.Type.Rule) {
contextMenu.appendSeparator();
for (let pseudoElement of WI.CSSManager.PseudoElementNames) {
let pseudoElementSelector = "::" + pseudoElement;
contextMenu.appendItem(WI.UIString("Create %s Rule").format(pseudoElementSelector), () => {
addPseudoRule(pseudoElementSelector, "content: \"\";");
});
}
}
}
}
if (this._style.ownerRule && this._style.ownerRule.sourceCodeLocation) {
contextMenu.appendSeparator();
let label = null;
let sourceCode = this._style.ownerRule.sourceCodeLocation.displaySourceCode;
if (sourceCode instanceof WI.CSSStyleSheet || (sourceCode instanceof WI.Resource && sourceCode.type === WI.Resource.Type.StyleSheet))
label = WI.UIString("Reveal in Style Sheet");
else if (WI.settings.experimentalEnableSourcesTab.value)
label = WI.UIString("Reveal in Sources Tab");
else
label = WI.UIString("Reveal in Resources Tab");
contextMenu.appendItem(label, () => {
WI.showSourceCodeLocation(this._style.ownerRule.sourceCodeLocation, {
ignoreNetworkTab: true,
ignoreSearchTab: true,
});
});
}
}
_handleWindowClick(event)
{
if (this._propertiesEditor.hasSelectedProperties()) {
// Don't start editing name/value if there's selection.
event.stop();
}
this._stopSelection();
}
_handleWindowMouseMove(event)
{
console.assert(this._mouseDownPoint);
if (this._mouseDownPoint.distance(WI.Point.fromEvent(event)) < 8)
return;
if (!this._propertiesEditor.hasSelectedProperties()) {
console.assert(!isNaN(this._mouseDownIndex));
this._propertiesEditor.selectProperties(this._mouseDownIndex, this._mouseDownIndex);
}
window.removeEventListener("mousemove", this._boundHandleWindowMouseMove);
this._mouseDownPoint = null;
}
_handleClick(event)
{
this._stopSelection();
if (this._wasEditing || this._propertiesEditor.hasSelectedProperties())
return;
if (window.getSelection().type === "Range")
return;
event.stop();
if (event.target.classList.contains(WI.SpreadsheetStyleProperty.StyleClassName)) {
let propertyIndex = parseInt(event.target.dataset.propertyIndex);
this._propertiesEditor.addBlankProperty(propertyIndex + 1);
return;
}
if (event.target === this._headerElement || event.target === this._openBrace) {
this._propertiesEditor.addBlankProperty(0);
return;
}
if (event.target === this._element || event.target === this._closeBrace) {
const appendAfterLast = -1;
this._propertiesEditor.addBlankProperty(appendAfterLast);
}
}
_stopSelection()
{
this._isMousePressed = false;
this._mouseDownIndex = NaN;
this._element.classList.remove("selecting");
// "copy" and "cut" events won't fire on SpreadsheetCSSStyleDeclarationEditor unless it has text selected.
// Placing a text caret inside of a property has no visible effects but it allows the events to fire.
this._propertiesEditor.placeTextCaretInFocusedProperty();
window.removeEventListener("mousemove", this._boundHandleWindowMouseMove);
this._mouseDownPoint = null;
}
_highlightNodesWithSelector()
{
let node = this._style.node;
if (!this._style.ownerRule) {
WI.domManager.highlightDOMNode(node.id);
return;
}
let selectorText = this._selectorElement.textContent.trim();
if (node.frame)
WI.domManager.highlightSelector(selectorText, node.frame.id);
else
WI.domManager.highlightSelector(selectorText);
}
_hideDOMNodeHighlight()
{
WI.domManager.hideDOMNodeHighlight();
}
_handleEditorFilterApplied(event)
{
let matchesGrouping = false;
for (let groupingElement of this._groupingElements) {
groupingElement.classList.remove(WI.GeneralStyleDetailsSidebarPanel.FilterMatchSectionClassName);
if (groupingElement.textContent.includes(this._filterText)) {
groupingElement.classList.add(WI.GeneralStyleDetailsSidebarPanel.FilterMatchSectionClassName);
matchesGrouping = true;
}
}
let matchesSelector = false;
for (let selectorElement of this._selectorElements) {
selectorElement.classList.remove(WI.GeneralStyleDetailsSidebarPanel.FilterMatchSectionClassName);
if (selectorElement.textContent.includes(this._filterText)) {
selectorElement.classList.add(WI.GeneralStyleDetailsSidebarPanel.FilterMatchSectionClassName);
matchesSelector = true;
}
}
let matches = event.data.matches || matchesGrouping || matchesSelector;
if (!matches)
this._element.classList.add(WI.GeneralStyleDetailsSidebarPanel.NoFilterMatchInSectionClassName);
this.dispatchEventToListeners(WI.SpreadsheetCSSStyleDeclarationSection.Event.FilterApplied, {matches});
}
};
WI.SpreadsheetCSSStyleDeclarationSection.Event = {
FilterApplied: "spreadsheet-css-style-declaration-section-filter-applied",
SelectorWillChange: "spreadsheet-css-style-declaration-section-selector-will-change",
};
WI.SpreadsheetCSSStyleDeclarationSection.MatchedSelectorElementStyleClassName = "matched";