path: root/bundles/org.eclipse.wst.css.core/src/org/eclipse/wst/css/core/internal/document/CSSModelImpl.java

/*******************************************************************************
 * Copyright (c) 2001, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.css.core.internal.document;



import java.util.Iterator;
import java.util.List;
import java.util.Vector;

import org.eclipse.wst.css.core.internal.event.ICSSStyleListener;
import org.eclipse.wst.css.core.internal.eventimpl.CSSEmbededStyleNotifyAdapter;
import org.eclipse.wst.css.core.internal.eventimpl.CSSStyleNotifyAdapter;
import org.eclipse.wst.css.core.internal.parser.CSSSourceParser;
import org.eclipse.wst.css.core.internal.provisional.document.ICSSAttr;
import org.eclipse.wst.css.core.internal.provisional.document.ICSSDocument;
import org.eclipse.wst.css.core.internal.provisional.document.ICSSImportRule;
import org.eclipse.wst.css.core.internal.provisional.document.ICSSModel;
import org.eclipse.wst.css.core.internal.provisional.document.ICSSNode;
import org.eclipse.wst.css.core.internal.provisional.document.ICSSSelector;
import org.eclipse.wst.css.core.internal.provisional.document.ICSSSelectorList;
import org.eclipse.wst.css.core.internal.provisional.document.ICSSStyleDeclaration;
import org.eclipse.wst.css.core.internal.provisional.document.ICSSStyleRule;
import org.eclipse.wst.css.core.internal.provisional.document.ICSSValue;
import org.eclipse.wst.css.core.internal.util.ImportRuleCollector;
import org.eclipse.wst.css.core.internal.util.ImportedCollector;
import org.eclipse.wst.css.core.internal.util.SelectorsCollector;
import org.eclipse.wst.sse.core.internal.ltk.parser.RegionParser;
import org.eclipse.wst.sse.core.internal.model.AbstractStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion;
import org.eclipse.wst.sse.core.internal.provisional.events.IStructuredDocumentListener;
import org.eclipse.wst.sse.core.internal.provisional.events.NewDocumentEvent;
import org.eclipse.wst.sse.core.internal.provisional.events.NoChangeEvent;
import org.eclipse.wst.sse.core.internal.provisional.events.RegionChangedEvent;
import org.eclipse.wst.sse.core.internal.provisional.events.RegionsReplacedEvent;
import org.eclipse.wst.sse.core.internal.provisional.events.StructuredDocumentRegionsReplacedEvent;
import org.eclipse.wst.sse.core.internal.provisional.exceptions.ResourceInUse;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegionList;
import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion;
import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegionList;
import org.eclipse.wst.sse.core.internal.util.Assert;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
import org.w3c.dom.Element;
import org.w3c.dom.Node;



public class CSSModelImpl extends AbstractStructuredModel implements ICSSModel, IStructuredDocumentListener {

	private CSSDocumentImpl document = null;
	private org.w3c.dom.Node ownerNode = null;
	private CSSStyleNotifyAdapter styleNotifier = null;
	private CSSModelParser fParser = null;
	private CSSModelUpdater fUpdater = null;
	private boolean fStructuredDocumentUpdate = false;
	private final static String ID_NON_EXTERNAL_CSS = "**_NON_EXTERNAL_CSS_***";//$NON-NLS-1$

	/**
	 * CSSModelImpl constructor comment.
	 * 
	 */
	public CSSModelImpl() {
		super();
	}

	/**
	 * @param listener
	 *            org.eclipse.wst.css.core.event.CSSStyleListener
	 */
	public void addStyleListener(ICSSStyleListener listener) {
		getStyleNotifier().addStyleListener(listener);
	}

	void attrReplaced(CSSNodeImpl parentNode, CSSNodeImpl newAttr, CSSNodeImpl oldAttr) {
		if (!fStructuredDocumentUpdate) {
			CSSModelUpdater updater = getUpdater();
			updater.attrReplaced(parentNode, newAttr, oldAttr);
		}

		ICSSSelector removed[] = null, added[] = null;
		if (oldAttr != null && oldAttr.getNodeType() == ICSSNode.ATTR_NODE && ((CSSAttrImpl) oldAttr).getName().equals(ICSSStyleRule.SELECTOR)) {
			CSSAttrImpl attr = (CSSAttrImpl) oldAttr;
			// collect changed selector
			ICSSSelectorList list = new CSSSelectorListImpl(attr.getValue());
			removed = new ICSSSelector[list.getLength()];
			for (int i = 0; i < list.getLength(); i++)
				removed[i] = list.getSelector(i);
		}
		if (newAttr != null && newAttr.getNodeType() == ICSSNode.ATTR_NODE && ((CSSAttrImpl) newAttr).getName().equals(ICSSStyleRule.SELECTOR)) {
			CSSAttrImpl attr = (CSSAttrImpl) newAttr;
			// collect changed selector
			ICSSSelectorList list = new CSSSelectorListImpl(attr.getValue());
			added = new ICSSSelector[list.getLength()];
			for (int i = 0; i < list.getLength(); i++)
				added[i] = list.getSelector(i);
		}
		if (removed != null || added != null || getDocument().getNodeType() == ICSSNode.STYLEDECLARATION_NODE) {
			getStyleNotifier().fire(removed, added, null);
		}
		// for href attribute
		if (getStyleListeners() != null && getStyleListeners().size() > 0) {
			boolean update = false;
			if (oldAttr != null && oldAttr.getNodeType() == ICSSNode.ATTR_NODE && ((CSSAttrImpl) oldAttr).getName().equals(ICSSImportRule.HREF)) {
				update = true;
			}
			if (newAttr != null && newAttr.getNodeType() == ICSSNode.ATTR_NODE && ((CSSAttrImpl) newAttr).getName().equals(ICSSImportRule.HREF)) {
				update = true;
			}
			if (update)
				((ICSSImportRule) parentNode).getStyleSheet();
		}
	}

	/**
	 * 
	 */
	public void beginRecording(Object requester, String label, String description) {
		getStyleNotifier().beginRecording();

		Node node = getOwnerDOMNode();
		if (node != null && node instanceof IDOMNode) {
			IStructuredModel model = ((IDOMNode) node).getModel();
			if (model != null) {
				model.beginRecording(requester, label, description);
				return;
			}
		}
		super.beginRecording(requester, label, description);
	}

	void childReplaced(CSSNodeImpl parentNode, CSSNodeImpl newChild, CSSNodeImpl oldChild) {
		if (!fStructuredDocumentUpdate) {
			CSSModelUpdater updater = getUpdater();
			updater.childReplaced(parentNode, newChild, oldChild);
		}

		// always check and send selector event
		ICSSSelector removed[] = null, added[] = null;
		if (parentNode.getNodeType() == ICSSNode.STYLESHEET_NODE || parentNode.getNodeType() == ICSSNode.MEDIARULE_NODE) {
			// collect old selectors
			SelectorsCollector selTrav = new SelectorsCollector();
			selTrav.apply(oldChild);
			int nSel = selTrav.getSelectors().size();
			if (nSel > 0) {
				removed = new ICSSSelector[nSel];
				for (int i = 0; i < nSel; i++)
					removed[i] = (ICSSSelector) selTrav.getSelectors().get(i);
			}
			// collect new selectors
			selTrav = new SelectorsCollector();
			selTrav.apply(newChild);
			nSel = selTrav.getSelectors().size();
			if (nSel > 0) {
				added = new ICSSSelector[nSel];
				for (int i = 0; i < nSel; i++)
					added[i] = (ICSSSelector) selTrav.getSelectors().get(i);
			}
		}
		else {
			// modification
			ICSSNode rule = parentNode;
			while (rule != null) {
				if (rule instanceof ICSSStyleRule)
					break;
				rule = rule.getParentNode();
			}
			if (rule != null) {
				ICSSSelectorList list = ((ICSSStyleRule) rule).getSelectors();
				added = new ICSSSelector[list.getLength()];
				for (int i = 0; i < list.getLength(); i++)
					added[i] = list.getSelector(i);
			}
		}
		if (removed != null || added != null || getDocument().getNodeType() == ICSSNode.STYLEDECLARATION_NODE) {
			// send selector changed event
			getStyleNotifier().fire(removed, added, null);
		}
		// close removed import-rule's external style sheets
		{
			ImportRuleCollector trav = new ImportRuleCollector();
			trav.apply(oldChild);
			Iterator it = trav.getRules().iterator();
			while (it.hasNext()) {
				((CSSImportRuleImpl) it.next()).closeStyleSheet();
			}
		}
		// send events to listener for new import-rules
		if (getStyleListeners() != null && getStyleListeners().size() > 0) {
			ImportedCollector trav = new ImportedCollector();
			trav.apply(newChild);
		}
	}

	/**
	 * 
	 */
	private void closeImported() {
		if (!isShared()) {
			// release listeners
			if (getStyleListeners() != null) {
				Vector toRemove = new Vector(getStyleListeners());
				Iterator it = toRemove.iterator();
				while (it.hasNext()) {
					removeStyleListener((ICSSStyleListener) it.next());
				}
			}
			// close import rules
			ImportRuleCollector trav = new ImportRuleCollector();
			trav.apply(getDocument());
			Iterator it2 = trav.getRules().iterator();
			while (it2.hasNext()) {
				((CSSImportRuleImpl) it2.next()).releaseRule();
			}
		}
	}

	private CSSDocumentImpl createDocument() {
		CSSDocumentImpl doc = null;
		int parserMode = CSSSourceParser.MODE_STYLESHEET;
		if (ownerNode == null) {
			// this case is external CSS file
			doc = (CSSStyleSheetImpl) DOMCSSImpl.createCSSStyleSheet(null, null); // parameters
			// are
			// for
			// STYLE-tag
			parserMode = CSSSourceParser.MODE_STYLESHEET;
		}
		else if (ownerNode instanceof org.w3c.dom.Element && ((Element) ownerNode).getTagName().toUpperCase().equals("STYLE")) {//$NON-NLS-1$
			// this case is STYLE-tag
			Element style = (Element) ownerNode;
			doc = (CSSStyleSheetImpl) DOMCSSImpl.createCSSStyleSheet(style.getAttribute("TITLE"), //$NON-NLS-1$
						style.getAttribute("MEDIA"));//$NON-NLS-1$
			parserMode = CSSSourceParser.MODE_STYLESHEET;
		}
		else if (ownerNode instanceof org.w3c.dom.Element || ownerNode instanceof org.w3c.dom.Attr) {
			// Inline attributes
			doc = (CSSStyleDeclarationImpl) DOMCSSImpl.createCSSStyleDeclaration();
			parserMode = CSSSourceParser.MODE_DECLARATION;
		}
		RegionParser regionParser = getStructuredDocument().getParser();
		if (regionParser instanceof CSSSourceParser) {
			((CSSSourceParser) regionParser).setParserMode(parserMode);
		}
		return doc;
	}

	/**
	 * 
	 */
	public void endRecording(Object requester) {
		Node node = getOwnerDOMNode();
		if (node != null && node instanceof IDOMNode) {
			IStructuredModel model = ((IDOMNode) node).getModel();
			if (model != null) {
				model.endRecording(requester);
				return;
			}
		}
		super.endRecording(requester);

		getStyleNotifier().endRecording();
	}

	public ICSSDocument getDocument() {
		if (document == null) {
			this.document = createDocument();
			this.document.setModel(this);
		}
		return this.document;
	}

	public IStructuredDocument getStructuredDocument() {
		IStructuredDocument structuredDocument = null;
		structuredDocument = super.getStructuredDocument();
		if (structuredDocument != null)
			return structuredDocument;

		// the first time
		Assert.isNotNull(getModelHandler());
		structuredDocument = (IStructuredDocument) getModelHandler().getDocumentLoader().createNewStructuredDocument();

		setStructuredDocument(structuredDocument);
		return structuredDocument;
	}

	/**
	 * getNode method comment.
	 */
	public IndexedRegion getIndexedRegion(int offset) {
		if (getDocument() == null)
			return null;
		return ((CSSStructuredDocumentRegionContainer) getDocument()).getContainerNode(offset);
	}

	/**
	 * @return org.w3c.dom.Node
	 */
	public Node getOwnerDOMNode() {
		return ownerNode;
	}

	/**
	 * @param ownerNode
	 *            org.w3c.dom.Node if the case of external CSS model, you
	 *            should set null, else if internal css, you should set
	 *            STYLE-tag node, else if inline css, you should set the
	 *            element that is the owner of style-attribute.
	 */
	public void setOwnerDOMNode(Node node) {
		// prohibit owner change
		Assert.isTrue(ownerNode == null);
		ownerNode = node;
		if (ownerNode != null) { // for internal/inline CSS context
			try {
				setId(ID_NON_EXTERNAL_CSS);
			}
			catch (ResourceInUse e) {
				// impossible
			}
		}
	}

	/**
	 * currently public but may be made default access protected in future.
	 */
	protected CSSModelParser getParser() {
		if (fParser == null) {
			if (getDocument() != null) {
				fParser = new CSSModelParser(document);
			}
		}
		return fParser;
	}

	/**
	 * @return java.util.List
	 */
	public List getStyleListeners() {
		return getStyleNotifier().getStyleListeners();
	}

	/**
	 * 
	 * @return java.lang.Object
	 */
	public java.lang.Object getStyleSheetType() {
		if (getDocument() instanceof ICSSStyleDeclaration)
			return INLINE;
		if (getOwnerDOMNode() != null)
			return EMBEDDED;
		else
			return EXTERNAL;
	}

	private CSSStyleNotifyAdapter getStyleNotifier() {
		if (styleNotifier == null) {
			styleNotifier = (ownerNode != null) ? new CSSEmbededStyleNotifyAdapter(this) : new CSSStyleNotifyAdapter(this);
		}
		return styleNotifier;
	}

	/**
	 * 
	 */
	private CSSModelUpdater getUpdater() {
		if (fUpdater == null) {
			fUpdater = new CSSModelUpdater(this);
			fUpdater.setParser(getParser());
		}
		return fUpdater;
	}

	/**
	 */
	public boolean isRecording() {
		return getStyleNotifier().isRecording();
	}

	/**
	 * This function returns true if there are other references to the
	 * underlying model.
	 */
	public boolean isShared() {
		return (getStyleSheetType() == EXTERNAL) && super.isShared();
	}

	public void newModel(NewDocumentEvent structuredDocumentEvent) {
		if (structuredDocumentEvent == null)
			return;
		IStructuredDocument structuredDocument = structuredDocumentEvent.getStructuredDocument();
		if (structuredDocument == null)
			return;
		// this should not happen, but for the case
		if (structuredDocument != getStructuredDocument())
			setStructuredDocument(structuredDocument);
		IStructuredDocumentRegionList flatNodes = structuredDocument.getRegionList();
		if (flatNodes == null)
			return;
		if (getDocument() == null)
			return;

		fStructuredDocumentUpdate = true;

		((CSSStructuredDocumentRegionContainer) getDocument()).removeChildNodes();

		CSSModelParser parser = getParser();
		parser.setStructuredDocumentEvent(structuredDocumentEvent);
		parser.replaceStructuredDocumentRegions(flatNodes, null);

		fStructuredDocumentUpdate = false;
	}

	/**
	 * noChange method comment.
	 */
	public void noChange(NoChangeEvent structuredDocumentEvent) {
		// nop
	}

	public void nodesReplaced(StructuredDocumentRegionsReplacedEvent structuredDocumentEvent) {
		if (structuredDocumentEvent == null) {
			return;
		}
		IStructuredDocumentRegionList oldStructuredDocumentRegions = structuredDocumentEvent.getOldStructuredDocumentRegions();
		IStructuredDocumentRegionList newStructuredDocumentRegions = structuredDocumentEvent.getNewStructuredDocumentRegions();
		if (oldStructuredDocumentRegions == null && newStructuredDocumentRegions == null) {
			return;
		}

		fStructuredDocumentUpdate = true;

		CSSModelParser parser = getParser();
		parser.setStructuredDocumentEvent(structuredDocumentEvent);
		parser.replaceStructuredDocumentRegions(newStructuredDocumentRegions, oldStructuredDocumentRegions);

		fStructuredDocumentUpdate = false;
	}

	/**
	 * cleanup -> rebuild CSS Nodes This is pre-beta fix for 178176.
	 */
	public void refreshNodes() {
		// cleanup old nodes
		fStructuredDocumentUpdate = true;
		((CSSStructuredDocumentRegionContainer) getDocument()).removeChildNodes();
		fStructuredDocumentUpdate = false;

		getParser().cleanupUpdateContext();

		IStructuredDocument structuredDocument = getStructuredDocument();
		String source = structuredDocument.getText();

		structuredDocument.replaceText(this, 0, source.length(), null);
		structuredDocument.replaceText(this, 0, 0, source);
	}

	public void regionChanged(RegionChangedEvent structuredDocumentEvent) {
		if (structuredDocumentEvent == null) {
			return;
		}
		IStructuredDocumentRegion flatNode = structuredDocumentEvent.getStructuredDocumentRegion();
		if (flatNode == null) {
			return;
		}
		ITextRegion region = structuredDocumentEvent.getRegion();
		if (region == null) {
			return;
		}

		fStructuredDocumentUpdate = true;

		CSSModelParser parser = getParser();
		parser.setStructuredDocumentEvent(structuredDocumentEvent);
		parser.changeRegion(flatNode, region);

		fStructuredDocumentUpdate = false;
	}

	public void regionsReplaced(RegionsReplacedEvent structuredDocumentEvent) {
		if (structuredDocumentEvent == null)
			return;
		IStructuredDocumentRegion flatNode = structuredDocumentEvent.getStructuredDocumentRegion();
		if (flatNode == null)
			return;
		ITextRegionList oldRegions = structuredDocumentEvent.getOldRegions();
		ITextRegionList newRegions = structuredDocumentEvent.getNewRegions();
		if (oldRegions == null && newRegions == null)
			return;

		fStructuredDocumentUpdate = true;

		CSSModelParser parser = getParser();
		parser.setStructuredDocumentEvent(structuredDocumentEvent);
		parser.replaceRegions(flatNode, newRegions, oldRegions);

		fStructuredDocumentUpdate = false;

	}

	/**
	 * 
	 */
	public void releaseFromEdit() {
		closeImported();
		if (getStyleSheetType() == EXTERNAL) {
			super.releaseFromEdit();
		}
	}

	/**
	 * 
	 */
	public void releaseFromRead() {
		closeImported();
		if (getStyleSheetType() == EXTERNAL) {
			super.releaseFromRead();
		}
	}

	/**
	 * @param listener
	 *            org.eclipse.wst.css.core.event.CSSStyleListener
	 */
	public void removeStyleListener(ICSSStyleListener listener) {
		getStyleNotifier().removeStyleListener(listener);
	}

	public void setStructuredDocument(IStructuredDocument newStructuredDocument) {
		IStructuredDocument oldStructuredDocument = super.getStructuredDocument();
		if (newStructuredDocument == oldStructuredDocument)
			return; // noting to do

		if (oldStructuredDocument != null)
			oldStructuredDocument.removeDocumentChangingListener(this);
		super.setStructuredDocument(newStructuredDocument);

		if (newStructuredDocument != null) {
			if (newStructuredDocument.getLength() > 0) {
				newModel(new NewDocumentEvent(newStructuredDocument, this));
			}
			newStructuredDocument.addDocumentChangingListener(this);
		}
	}

	/**
	 * @param srcModel
	 *            com.imb.sed.css.mode.intefaces.ICSSModel
	 * @param removed
	 *            org.eclipse.wst.css.core.model.interfaces.ICSSSelector[]
	 * @param added
	 *            org.eclipse.wst.css.core.model.interfaces.ICSSSelector[]
	 */
	public void styleChanged(ICSSModel srcModel, ICSSSelector[] removed, ICSSSelector[] added, String media) {
		getStyleNotifier().styleChanged(srcModel, removed, added, media);
	}

	/**
	 * @param srcModel
	 *            org.eclipse.wst.css.core.model.interfaces.ICSSModel
	 */
	public void styleUpdate(ICSSModel srcModel) {
		getStyleNotifier().styleUpdate(srcModel);
	}

	void valueChanged(CSSNodeImpl node, String oldValue) {
		if (!fStructuredDocumentUpdate) {
			CSSModelUpdater updater = getUpdater();
			updater.valueChanged(node, oldValue);
		}

		ICSSSelector removed[] = null, added[] = null;
		if (node != null) {
			if (node.getNodeType() == ICSSNode.ATTR_NODE && ((CSSAttrImpl) node).getName().equals(ICSSStyleRule.SELECTOR)) {
				CSSAttrImpl attr = (CSSAttrImpl) node;
				// collect changed selector
				ICSSSelectorList list = new CSSSelectorListImpl(attr.getValue());
				added = new ICSSSelector[list.getLength()];
				for (int i = 0; i < list.getLength(); i++)
					added[i] = list.getSelector(i);

				// get old value
				list = new CSSSelectorListImpl(oldValue);
				removed = new ICSSSelector[list.getLength()];
				for (int i = 0; i < list.getLength(); i++)
					removed[i] = list.getSelector(i);
			}
			else if (node instanceof ICSSValue) {
				ICSSNode rule = node;
				while (rule != null) {
					if (rule instanceof ICSSStyleRule)
						break;
					rule = rule.getParentNode();
				}
				if (rule != null) {
					ICSSSelectorList list = ((ICSSStyleRule) rule).getSelectors();
					added = new ICSSSelector[list.getLength()];
					for (int i = 0; i < list.getLength(); i++)
						added[i] = list.getSelector(i);
				}
			}
		}
		if (removed != null || added != null || getDocument().getNodeType() == ICSSNode.STYLEDECLARATION_NODE) {
			// send selector changed event
			getStyleNotifier().fire(removed, added, null);
		}
		// for href attribute
		if (getStyleListeners() != null && getStyleListeners().size() > 0) {
			if (node != null && node.getNodeType() == ICSSNode.ATTR_NODE && ((CSSAttrImpl) node).getName().equals(ICSSImportRule.HREF)) {
				((ICSSImportRule) ((ICSSAttr) node).getOwnerCSSNode()).getStyleSheet();
			}
		}
	}
}