org.eclipse.e4.ui.css.core_0.10.2.v20120912-132817

get, "white-space", null);
  }
  
  public String getWidows()
  {
    return engine.retrieveCSSProperty(widget, "widows", null);
  }
  
  public String getWidth()
  {
    return engine.retrieveCSSProperty(widget, "width", null);
  }
  
  public String getWordSpacing()
  {
    return engine.retrieveCSSProperty(widget, "word-spacing", null);
  }
  
  public String getZIndex()
  {
    return engine.retrieveCSSProperty(widget, "z-index", null);
  }
  
  public void setAzimuth(String azimuth)
    throws DOMException
  {
    parseAndApplyStyle("azimuth", azimuth);
  }
  
  public void setBackground(String background)
    throws DOMException
  {
    parseAndApplyStyle("background", background);
  }
  
  public void setBackgroundAttachment(String backgroundAttachment)
    throws DOMException
  {
    parseAndApplyStyle("background-attachment", backgroundAttachment);
  }
  
  public void setBackgroundColor(String backgroundColor)
    throws DOMException
  {
    parseAndApplyStyle("background-color", backgroundColor);
  }
  
  public void setBackgroundImage(String backgroundImage)
    throws DOMException
  {
    parseAndApplyStyle("background-image", backgroundImage);
  }
  
  public void setBackgroundPosition(String backgroundPosition)
    throws DOMException
  {
    parseAndApplyStyle("background-position", backgroundPosition);
  }
  
  public void setBackgroundRepeat(String backgroundRepeat)
    throws DOMException
  {
    parseAndApplyStyle("background-repeat", backgroundRepeat);
  }
  
  public void setBorder(String border)
    throws DOMException
  {
    parseAndApplyStyle("border", border);
  }
  
  public void setBorderBottom(String borderBottom)
    throws DOMException
  {
    parseAndApplyStyle("border-bottom", borderBottom);
  }
  
  public void setBorderBottomColor(String borderColor)
    throws DOMException
  {
    parseAndApplyStyle("border-color", borderColor);
  }
  
  public void setBorderBottomStyle(String borderBottomStyle)
    throws DOMException
  {
    parseAndApplyStyle("border-bottom-style", borderBottomStyle);
  }
  
  public void setBorderBottomWidth(String borderBottomWidth)
    throws DOMException
  {
    parseAndApplyStyle("border-bottom-width", borderBottomWidth);
  }
  
  public void setBorderCollapse(String borderCollapse)
    throws DOMException
  {
    parseAndApplyStyle("border-collapse", borderCollapse);
  }
  
  public void setBorderColor(String borderColor)
    throws DOMException
  {
    parseAndApplyStyle("border-color", borderColor);
  }
  
  public void setBorderLeft(String borderLeft)
    throws DOMException
  {
    parseAndApplyStyle("border-left", borderLeft);
  }
  
  public void setBorderLeftColor(String borderLeftColor)
    throws DOMException
  {
    parseAndApplyStyle("border-left-color", borderLeftColor);
  }
  
  public void setBorderLeftStyle(String borderLeftStyle)
    throws DOMException
  {
    parseAndApplyStyle("border-left-style", borderLeftStyle);
  }
  
  public void setBorderLeftWidth(String borderLeftWidth)
    throws DOMException
  {
    parseAndApplyStyle("border-left-width", borderLeftWidth);
  }
  
  public void setBorderRight(String borderRight)
    throws DOMException
  {
    parseAndApplyStyle("border-right", borderRight);
  }
  
  public void setBorderRightColor(String borderRightColor)
    throws DOMException
  {
    parseAndApplyStyle("border-right-color", borderRightColor);
  }
  
  public void setBorderRightStyle(String borderRightStyle)
    throws DOMException
  {
    parseAndApplyStyle("border-right-style", borderRightStyle);
  }
  
  public void setBorderRightWidth(String borderRightWidth)
    throws DOMException
  {
    parseAndApplyStyle("border-right-width", borderRightWidth);
  }
  
  public void setBorderSpacing(String borderSpacing)
    throws DOMException
  {
    parseAndApplyStyle("border-spacing", borderSpacing);
  }
  
  public void setBorderStyle(String borderStyle)
    throws DOMException
  {
    parseAndApplyStyle("border-style", borderStyle);
  }
  
  public void setBorderTop(String borderTop)
    throws DOMException
  {
    parseAndApplyStyle("border-top", borderTop);
  }
  
  public void setBorderTopColor(String borderTopColor)
    throws DOMException
  {
    parseAndApplyStyle("border-top-color", borderTopColor);
  }
  
  public void setBorderTopStyle(String borderTopStyle)
    throws DOMException
  {
    parseAndApplyStyle("border-top-style", borderTopStyle);
  }
  
  public void setBorderTopWidth(String borderTopWidth)
    throws DOMException
  {
    parseAndApplyStyle("border-top-width", borderTopWidth);
  }
  
  public void setBorderWidth(String borderWidth)
    throws DOMException
  {
    parseAndApplyStyle("border-width", borderWidth);
  }
  
  public void setBottom(String bottom)
    throws DOMException
  {
    parseAndApplyStyle("bottom", bottom);
  }
  
  public void setCaptionSide(String captionSide)
    throws DOMException
  {
    parseAndApplyStyle("caption-side", captionSide);
  }
  
  public void setClear(String clear)
    throws DOMException
  {
    parseAndApplyStyle("clear", clear);
  }
  
  public void setClip(String clip)
    throws DOMException
  {
    parseAndApplyStyle("clip", clip);
  }
  
  public void setColor(String color)
    throws DOMException
  {
    parseAndApplyStyle("color", color);
  }
  
  public void setContent(String content)
    throws DOMException
  {
    parseAndApplyStyle("content", content);
  }
  
  public void setCounterIncrement(String counterIncrement)
    throws DOMException
  {
    parseAndApplyStyle("counter-increment", counterIncrement);
  }
  
  public void setCounterReset(String counterReset)
    throws DOMException
  {
    parseAndApplyStyle("counter-reset", counterReset);
  }
  
  public void setCssFloat(String cssFloat)
    throws DOMException
  {
    parseAndApplyStyle("float", cssFloat);
  }
  
  public void setCue(String cue)
    throws DOMException
  {
    parseAndApplyStyle("cue", cue);
  }
  
  public void setCueAfter(String cueAfter)
    throws DOMException
  {
    parseAndApplyStyle("cue-after", cueAfter);
  }
  
  public void setCueBefore(String cueBefore)
    throws DOMException
  {
    parseAndApplyStyle("cue-before", cueBefore);
  }
  
  public void setCursor(String cursor)
    throws DOMException
  {
    parseAndApplyStyle("cursor", cursor);
  }
  
  public void setDirection(String direction)
    throws DOMException
  {
    parseAndApplyStyle("direction", direction);
  }
  
  public void setDisplay(String display)
    throws DOMException
  {
    parseAndApplyStyle("display", display);
  }
  
  public void setElevation(String elevation)
    throws DOMException
  {
    parseAndApplyStyle("elevation", elevation);
  }
  
  public void setEmptyCells(String emptyCells)
    throws DOMException
  {
    parseAndApplyStyle("empty-cells", emptyCells);
  }
  
  public void setFont(String font)
    throws DOMException
  {
    parseAndApplyStyle("font", font);
  }
  
  public void setFontFamily(String fontFamily)
    throws DOMException
  {
    parseAndApplyStyle("font-family", fontFamily);
  }
  
  public void setFontSize(String fontSize)
    throws DOMException
  {
    parseAndApplyStyle("font-size", fontSize);
  }
  
  public void setFontSizeAdjust(String fontSizeAdjust)
    throws DOMException
  {
    parseAndApplyStyle("font-size-adjust", fontSizeAdjust);
  }
  
  public void setFontStretch(String fontStretch)
    throws DOMException
  {
    parseAndApplyStyle("font-stretch", fontStretch);
  }
  
  public void setFontStyle(String fontStyle)
    throws DOMException
  {
    parseAndApplyStyle("font-style", fontStyle);
  }
  
  public void setFontVariant(String fontVariant)
    throws DOMException
  {
    parseAndApplyStyle("font-variant", fontVariant);
  }
  
  public void setFontWeight(String fontWeight)
    throws DOMException
  {
    parseAndApplyStyle("font-weight", fontWeight);
  }
  
  public void setHeight(String height)
    throws DOMException
  {
    parseAndApplyStyle("height", height);
  }
  
  public void setLeft(String left)
    throws DOMException
  {
    parseAndApplyStyle("left", left);
  }
  
  public void setLetterSpacing(String letterSpacing)
    throws DOMException
  {
    parseAndApplyStyle("letter-spacing", letterSpacing);
  }
  
  public void setLineHeight(String lineHeight)
    throws DOMException
  {
    parseAndApplyStyle("line-height", lineHeight);
  }
  
  public void setListStyle(String listStyle)
    throws DOMException
  {
    parseAndApplyStyle("list-style", listStyle);
  }
  
  public void setListStyleImage(String listStyleImage)
    throws DOMException
  {
    parseAndApplyStyle("list-style-image", listStyleImage);
  }
  
  public void setListStylePosition(String listStylePosition)
    throws DOMException
  {
    parseAndApplyStyle("list-style-position", listStylePosition);
  }
  
  public void setListStyleType(String listStyleType)
    throws DOMException
  {
    parseAndApplyStyle("list-style-type", listStyleType);
  }
  
  public void setMargin(String margin)
    throws DOMException
  {
    parseAndApplyStyle("margin", margin);
  }
  
  public void setMarginBottom(String marginBottom)
    throws DOMException
  {
    parseAndApplyStyle("margin-bottom", marginBottom);
  }
  
  public void setMarginLeft(String marginLeft)
    throws DOMException
  {
    parseAndApplyStyle("margin-left", marginLeft);
  }
  
  public void setMarginRight(String marginRight)
    throws DOMException
  {
    parseAndApplyStyle("margin-right", marginRight);
  }
  
  public void setMarginTop(String marginTop)
    throws DOMException
  {
    parseAndApplyStyle("margin-top", marginTop);
  }
  
  public void setMarkerOffset(String markerOffset)
    throws DOMException
  {
    parseAndApplyStyle("marker-offset", markerOffset);
  }
  
  public void setMarks(String marks)
    throws DOMException
  {
    parseAndApplyStyle("marks", marks);
  }
  
  public void setMaxHeight(String maxHeight)
    throws DOMException
  {
    parseAndApplyStyle("max-height", maxHeight);
  }
  
  public void setMaxWidth(String maxWidth)
    throws DOMException
  {
    parseAndApplyStyle("max-width", maxWidth);
  }
  
  public void setMinHeight(String minHeight)
    throws DOMException
  {
    parseAndApplyStyle("min-height", minHeight);
  }
  
  public void setMinWidth(String minWidth)
    throws DOMException
  {
    parseAndApplyStyle("min-width", minWidth);
  }
  
  public void setOrphans(String orphans)
    throws DOMException
  {
    parseAndApplyStyle("orphans", orphans);
  }
  
  public void setOutline(String outline)
    throws DOMException
  {
    parseAndApplyStyle("outline", outline);
  }
  
  public void setOutlineColor(String outlineColor)
    throws DOMException
  {
    parseAndApplyStyle("outline-color", outlineColor);
  }
  
  public void setOutlineStyle(String outlineStyle)
    throws DOMException
  {
    parseAndApplyStyle("outline-style", outlineStyle);
  }
  
  public void setOutlineWidth(String outlineWidth)
    throws DOMException
  {
    parseAndApplyStyle("outline-width", outlineWidth);
  }
  
  public void setOverflow(String overflow)
    throws DOMException
  {
    parseAndApplyStyle("overflow", overflow);
  }
  
  public void setPadding(String padding)
    throws DOMException
  {
    parseAndApplyStyle("padding", padding);
  }
  
  public void setPaddingBottom(String paddingBottom)
    throws DOMException
  {
    parseAndApplyStyle("padding-bottom", paddingBottom);
  }
  
  public void setPaddingLeft(String paddingLeft)
    throws DOMException
  {
    parseAndApplyStyle("padding-left", paddingLeft);
  }
  
  public void setPaddingRight(String paddingRight)
    throws DOMException
  {
    parseAndApplyStyle("padding-right", paddingRight);
  }
  
  public void setPaddingTop(String paddingTop)
    throws DOMException
  {
    parseAndApplyStyle("padding-top", paddingTop);
  }
  
  public void setPage(String page)
    throws DOMException
  {
    parseAndApplyStyle("page", page);
  }
  
  public void setPageBreakAfter(String pageBreakAfter)
    throws DOMException
  {
    parseAndApplyStyle("page-break-after", pageBreakAfter);
  }
  
  public void setPageBreakBefore(String pageBreakBefore)
    throws DOMException
  {
    parseAndApplyStyle("page-break-before", pageBreakBefore);
  }
  
  public void setPageBreakInside(String pageBreakInside)
    throws DOMException
  {
    parseAndApplyStyle("page-break-inside", pageBreakInside);
  }
  
  public void setPause(String pause)
    throws DOMException
  {
    parseAndApplyStyle("pause", pause);
  }
  
  public void setPauseAfter(String pauseAfter)
    throws DOMException
  {
    parseAndApplyStyle("pause-after", pauseAfter);
  }
  
  public void setPauseBefore(String pauseBefore)
    throws DOMException
  {
    parseAndApplyStyle("pause-before", pauseBefore);
  }
  
  public void setPitch(String pitch)
    throws DOMException
  {
    parseAndApplyStyle("pitch", pitch);
  }
  
  public void setPitchRange(String pitchRange)
    throws DOMException
  {
    parseAndApplyStyle("pitch-range", pitchRange);
  }
  
  public void setPlayDuring(String playDuring)
    throws DOMException
  {
    parseAndApplyStyle("playDuring", playDuring);
  }
  
  public void setPosition(String position)
    throws DOMException
  {
    parseAndApplyStyle("position", position);
  }
  
  public void setQuotes(String quotes)
    throws DOMException
  {
    parseAndApplyStyle("quotes", quotes);
  }
  
  public void setRichness(String richness)
    throws DOMException
  {
    parseAndApplyStyle("richness", richness);
  }
  
  public void setRight(String right)
    throws DOMException
  {
    parseAndApplyStyle("right", right);
  }
  
  public void setSize(String size)
    throws DOMException
  {
    parseAndApplyStyle("size", size);
  }
  
  public void setSpeak(String speak)
    throws DOMException
  {
    parseAndApplyStyle("speak", speak);
  }
  
  public void setSpeakHeader(String speakHeader)
    throws DOMException
  {
    parseAndApplyStyle("speak-header", speakHeader);
  }
  
  public void setSpeakNumeral(String speakNumeral)
    throws DOMException
  {
    parseAndApplyStyle("speak-numeral", speakNumeral);
  }
  
  public void setSpeakPunctuation(String speakPunctuation)
    throws DOMException
  {
    parseAndApplyStyle("speak-punctuation", speakPunctuation);
  }
  
  public void setSpeechRate(String speechRate)
    throws DOMException
  {
    parseAndApplyStyle("speech-rate", speechRate);
  }
  
  public void setStress(String stress)
    throws DOMException
  {
    parseAndApplyStyle("stress", stress);
  }
  
  public void setTableLayout(String tableLayout)
    throws DOMException
  {
    parseAndApplyStyle("table-layout", tableLayout);
  }
  
  public void setTextAlign(String textAlign)
    throws DOMException
  {
    parseAndApplyStyle("text-align", textAlign);
  }
  
  public void setTextDecoration(String textDecoration)
    throws DOMException
  {
    parseAndApplyStyle("text-decoration", textDecoration);
  }
  
  public void setTextIndent(String textIndent)
    throws DOMException
  {
    parseAndApplyStyle("text-indent", textIndent);
  }
  
  public void setTextShadow(String textShadow)
    throws DOMException
  {
    parseAndApplyStyle("text-shadow", textShadow);
  }
  
  public void setTextTransform(String textTransform)
    throws DOMException
  {
    parseAndApplyStyle("text-transform", textTransform);
  }
  
  public void setTop(String top)
    throws DOMException
  {
    parseAndApplyStyle("top", top);
  }
  
  public void setUnicodeBidi(String unicodeBidi)
    throws DOMException
  {
    parseAndApplyStyle("unicode-bidi", unicodeBidi);
  }
  
  public void setVerticalAlign(String verticalAlign)
    throws DOMException
  {
    parseAndApplyStyle("vertical-align", verticalAlign);
  }
  
  public void setVisibility(String visibility)
    throws DOMException
  {
    parseAndApplyStyle("visibility", visibility);
  }
  
  public void setVoiceFamily(String voiceFamily)
    throws DOMException
  {
    parseAndApplyStyle("voice-family", voiceFamily);
  }
  
  public void setVolume(String volume)
    throws DOMException
  {
    parseAndApplyStyle("volume", volume);
  }
  
  public void setWhiteSpace(String whiteSpace)
    throws DOMException
  {
    parseAndApplyStyle("white-space", whiteSpace);
  }
  
  public void setWidows(String widows)
    throws DOMException
  {
    parseAndApplyStyle("widows", widows);
  }
  
  public void setWidth(String width)
    throws DOMException
  {
    parseAndApplyStyle("width", width);
  }
  
  public void setWordSpacing(String wordSpacing)
    throws DOMException
  {
    parseAndApplyStyle("word-spacing", wordSpacing);
  }
  
  public void setZIndex(String zIndex)
    throws DOMException
  {
    parseAndApplyStyle("z-index", zIndex);
  }
  
  protected void parseAndApplyStyle(String propertyName, String propertyValue)
  {
    try
    {
      String property = propertyName + ":" + propertyValue;
      engine.parseAndApplyStyleDeclaration(widget, property);
    }
    catch (Exception e)
    {
      throw new DOMException((short)12, e.getMessage());
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.e4.ui.css.core.impl.dom.CSS2PropertiesImpl
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.e4.ui.css.core.impl.dom;

import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import org.eclipse.e4.ui.css.core.dom.CSSProperty;
import org.eclipse.e4.ui.css.core.dom.CSSPropertyList;
import org.w3c.dom.css.CSSStyleDeclaration;

public class CSSComputedStyleImpl
  extends CSSStyleDeclarationImpl
  implements CSSStyleDeclaration
{
  private List<StyleWrapper> styleRules;
  
  public CSSComputedStyleImpl(List<StyleWrapper> styleRules)
  {
    super(null);
    this.styleRules = styleRules;
    
    Collections.sort(this.styleRules, StyleWrapper.COMPARATOR);
    Iterator iterator = this.styleRules.iterator();
    while (iterator.hasNext())
    {
      StyleWrapper styleWrapper = (StyleWrapper)iterator.next();
      addCSSPropertyList(((CSSStyleDeclarationImpl)style).getCSSPropertyList());
    }
  }
  
  private void addCSSPropertyList(CSSPropertyList properties)
  {
    int length = properties.getLength();
    for (int i = 0; i < length; i++)
    {
      CSSProperty property = properties.item(i);
      super.removeProperty(property.getName());
      super.addProperty(property);
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.e4.ui.css.core.impl.dom.CSSComputedStyleImpl
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.e4.ui.css.core.impl.dom;

import org.eclipse.e4.ui.css.core.dom.CSSExtendedProperties;
import org.eclipse.e4.ui.css.core.engine.CSSEngine;

public class CSSExtendedPropertiesImpl
  extends CSS2PropertiesImpl
  implements CSSExtendedProperties
{
  public CSSExtendedPropertiesImpl(Object widget, CSSEngine engine)
  {
    super(widget, engine);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.e4.ui.css.core.impl.dom.CSSExtendedPropertiesImpl
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.e4.ui.css.core.impl.dom;

import java.io.Serializable;
import org.w3c.dom.css.CSSFontFaceRule;
import org.w3c.dom.css.CSSRule;
import org.w3c.dom.css.CSSStyleDeclaration;
import org.w3c.dom.css.CSSStyleSheet;

public class CSSFontFaceRuleImpl
  extends CSSRuleImpl
  implements CSSFontFaceRule, Serializable
{
  public CSSFontFaceRuleImpl(CSSStyleSheet parentStyleSheet, CSSRule parentRule)
  {
    super(parentStyleSheet, parentRule);
    
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public short getType()
  {
    return 5;
  }
  
  public CSSStyleDeclaration getStyle()
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public void setStyle(CSSStyleDeclarationImpl decl)
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
}

/* Location:
 * Qualified Name:     org.eclipse.e4.ui.css.core.impl.dom.CSSFontFaceRuleImpl
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.e4.ui.css.core.impl.dom;

import java.io.Serializable;
import org.w3c.dom.css.CSSImportRule;
import org.w3c.dom.css.CSSRule;
import org.w3c.dom.css.CSSStyleSheet;
import org.w3c.dom.stylesheets.MediaList;

public class CSSImportRuleImpl
  extends CSSRuleImpl
  implements CSSImportRule, Serializable
{
  String uri;
  MediaListImpl mediaList;
  
  public CSSImportRuleImpl(CSSStyleSheet parentStyleSheet, CSSRule parentRule, String uri, MediaListImpl mediaListImpl)
  {
    super(parentStyleSheet, parentRule);
    this.uri = uri;
    mediaList = mediaListImpl;
  }
  
  public short getType()
  {
    return 3;
  }
  
  public String getHref()
  {
    return uri;
  }
  
  public MediaList getMedia()
  {
    return mediaList;
  }
  
  public CSSStyleSheet getStyleSheet()
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
}

/* Location:
 * Qualified Name:     org.eclipse.e4.ui.css.core.impl.dom.CSSImportRuleImpl
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.e4.ui.css.core.impl.dom;

import java.io.Serializable;
import org.w3c.dom.DOMException;
import org.w3c.dom.css.CSSMediaRule;
import org.w3c.dom.css.CSSRule;
import org.w3c.dom.css.CSSRuleList;
import org.w3c.dom.css.CSSStyleSheet;
import org.w3c.dom.stylesheets.MediaList;

public class CSSMediaRuleImpl
  extends CSSRuleImpl
  implements CSSMediaRule, Serializable
{
  public CSSMediaRuleImpl(CSSStyleSheet parentStyleSheet, CSSRule parentRule, MediaListImpl mediaListImpl)
  {
    super(parentStyleSheet, parentRule);
  }
  
  public short getType()
  {
    return 4;
  }
  
  public void deleteRule(int index)
    throws DOMException
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public CSSRuleList getCssRules()
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public MediaList getMedia()
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public int insertRule(String rule, int index)
    throws DOMException
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public void setRuleList(CSSRuleListImpl rules)
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
}

/* Location:
 * Qualified Name:     org.eclipse.e4.ui.css.core.impl.dom.CSSMediaRuleImpl
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.e4.ui.css.core.impl.dom;

import java.io.Serializable;
import org.w3c.dom.DOMException;
import org.w3c.dom.css.CSSPageRule;
import org.w3c.dom.css.CSSRule;
import org.w3c.dom.css.CSSStyleDeclaration;
import org.w3c.dom.css.CSSStyleSheet;

public class CSSPageRuleImpl
  extends CSSRuleImpl
  implements CSSPageRule, Serializable
{
  public CSSPageRuleImpl(CSSStyleSheet parentStyleSheet, CSSRule parentRule, String name, String pseudo_page)
  {
    super(parentStyleSheet, parentRule);
  }
  
  public short getType()
  {
    return 6;
  }
  
  public String getSelectorText()
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public CSSStyleDeclaration getStyle()
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public void setSelectorText(String arg0)
    throws DOMException
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public void setStyle(CSSStyleDeclarationImpl decl)
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
}

/* Location:
 * Qualified Name:     org.eclipse.e4.ui.css.core.impl.dom.CSSPageRuleImpl
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.e4.ui.css.core.impl.dom;

import java.io.Serializable;
import org.eclipse.e4.ui.css.core.dom.CSSProperty;
import org.w3c.dom.css.CSSValue;

public class CSSPropertyImpl
  implements CSSProperty, Serializable
{
  protected static String IMPORTANT_IDENTIFIER = "important";
  private String name;
  private CSSValue value;
  private boolean important;
  
  public static boolean sameName(CSSProperty property, String testName)
  {
    return property.getName().equalsIgnoreCase(testName);
  }
  
  public CSSPropertyImpl(String name, CSSValue value, boolean important)
  {
    this.name = name;
    this.value = value;
    this.important = important;
  }
  
  public String getName()
  {
    return name;
  }
  
  public CSSValue getValue()
  {
    return value;
  }
  
  public boolean isImportant()
  {
    return important;
  }
  
  public void setImportant(boolean important)
  {
    this.important = important;
  }
  
  public void setValue(CSSValue value)
  {
    this.value = value;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.e4.ui.css.core.impl.dom.CSSPropertyImpl
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.e4.ui.css.core.impl.dom;

import java.util.ArrayList;
import java.util.List;
import org.eclipse.e4.ui.css.core.dom.CSSProperty;
import org.eclipse.e4.ui.css.core.dom.CSSPropertyList;

public class CSSPropertyListImpl
  implements CSSPropertyList
{
  private List properties = null;
  
  public int getLength()
  {
    return properties != null ? properties.size() : 0;
  }
  
  public CSSProperty item(int index)
  {
    return properties != null ? (CSSProperty)properties.get(index) : 
      null;
  }
  
  public void add(CSSProperty property)
  {
    if (properties == null) {
      properties = new ArrayList();
    }
    properties.add(property);
  }
  
  public void insert(CSSProperty property, int index)
  {
    if (properties == null) {
      properties = new ArrayList();
    }
    properties.add(index, property);
  }
  
  public void delete(int index)
  {
    if (properties == null) {
      properties = new ArrayList();
    }
    properties.remove(index);
  }
  
  public String toString()
  {
    StringBuffer sb = new StringBuffer();
    for (int i = 0; i < getLength(); i++) {
      sb.append(item(i).toString()).append("\r\n");
    }
    return sb.toString();
  }
}

/* Location:
 * Qualified Name:     org.eclipse.e4.ui.css.core.impl.dom.CSSPropertyListImpl
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.e4.ui.css.core.impl.dom;

import org.eclipse.e4.ui.css.core.exceptions.DOMExceptionImpl;
import org.w3c.dom.DOMException;
import org.w3c.dom.css.CSSRule;
import org.w3c.dom.css.CSSStyleSheet;

public abstract class CSSRuleImpl
  extends AbstractCSSNode
  implements CSSRule
{
  private CSSStyleSheet parentStyleSheet = null;
  private CSSRule parentRule = null;
  private boolean readOnly;
  
  public CSSRuleImpl(CSSStyleSheet parentStyleSheet, CSSRule parentRule)
  {
    this.parentStyleSheet = parentStyleSheet;
    this.parentRule = parentRule;
  }
  
  public String getCssText()
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public CSSStyleSheet getParentStyleSheet()
  {
    return parentStyleSheet;
  }
  
  public CSSRule getParentRule()
  {
    return parentRule;
  }
  
  public abstract short getType();
  
  public void setCssText(String cssText)
    throws DOMException
  {
    if (readOnly) {
      throw new DOMExceptionImpl((short)7, 20);
    }
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
}

/* Location:
 * Qualified Name:     org.eclipse.e4.ui.css.core.impl.dom.CSSRuleImpl
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.e4.ui.css.core.impl.dom;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import org.w3c.dom.css.CSSRule;
import org.w3c.dom.css.CSSRuleList;

public class CSSRuleListImpl
  implements CSSRuleList, Serializable
{
  private List<CSSRule> ruleList;
  
  public CSSRuleListImpl()
  {
    ruleList = new ArrayList();
  }
  
  public int getLength()
  {
    return ruleList.size();
  }
  
  public CSSRule item(int position)
  {
    return (CSSRule)ruleList.get(position);
  }
  
  public void add(CSSRule rule)
  {
    ruleList.add(rule);
  }
  
  public void remove(int position)
  {
    ruleList.remove(position);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.e4.ui.css.core.impl.dom.CSSRuleListImpl
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.e4.ui.css.core.impl.dom;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.e4.ui.css.core.dom.CSSProperty;
import org.eclipse.e4.ui.css.core.dom.CSSPropertyList;
import org.eclipse.e4.ui.css.core.exceptions.DOMExceptionImpl;
import org.w3c.dom.DOMException;
import org.w3c.dom.css.CSSRule;
import org.w3c.dom.css.CSSStyleDeclaration;
import org.w3c.dom.css.CSSValue;

public class CSSStyleDeclarationImpl
  extends AbstractCSSNode
  implements CSSStyleDeclaration, Serializable
{
  private boolean readOnly;
  private CSSRule parentRule;
  private List<CSSProperty> properties = new ArrayList();
  
  public CSSStyleDeclarationImpl(CSSRule parentRule)
  {
    this.parentRule = parentRule;
  }
  
  public String getCssText()
  {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < properties.size(); i++)
    {
      CSSProperty property = (CSSProperty)properties.get(i);
      sb.append(property.getName()).append(": ");
      sb.append(property.getValue().getCssText());
      sb.append(";");
      if (i < properties.size() - 1) {
        sb.append("\n");
      }
    }
    return sb.toString();
  }
  
  public int getLength()
  {
    return properties.size();
  }
  
  public CSSRule getParentRule()
  {
    return parentRule;
  }
  
  public CSSValue getPropertyCSSValue(String propertyName)
  {
    CSSProperty property = findCSSProperty(propertyName);
    return property == null ? 
      null : 
      property.getValue();
  }
  
  public String getPropertyPriority(String propertyName)
  {
    CSSProperty property = findCSSProperty(propertyName);
    return (property != null) && (property.isImportant()) ? 
      CSSPropertyImpl.IMPORTANT_IDENTIFIER : 
      "";
  }
  
  public String getPropertyValue(String propertyName)
  {
    CSSProperty property = findCSSProperty(propertyName);
    return property == null ? 
      "" : 
      property.getValue().toString();
  }
  
  public String item(int index)
  {
    return ((CSSProperty)properties.get(index)).getName();
  }
  
  public String removeProperty(String propertyName)
    throws DOMException
  {
    if (readOnly) {
      throw new DOMExceptionImpl((short)7, 20);
    }
    for (int i = 0; i < properties.size(); i++)
    {
      CSSProperty property = (CSSProperty)properties.get(i);
      if (CSSPropertyImpl.sameName(property, propertyName))
      {
        properties.remove(i);
        return property.getValue().toString();
      }
    }
    return "";
  }
  
  public void setCssText(String cssText)
    throws DOMException
  {
    if (readOnly) {
      throw new DOMExceptionImpl((short)7, 20);
    }
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public void setProperty(String propertyName, String value, String priority)
    throws DOMException
  {
    if (readOnly) {
      throw new DOMExceptionImpl((short)7, 20);
    }
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public void addProperty(CSSProperty property)
  {
    properties.add(property);
  }
  
  public CSSPropertyList getCSSPropertyList()
  {
    CSSPropertyListImpl propertyList = new CSSPropertyListImpl();
    for (CSSProperty property : properties) {
      propertyList.add(property);
    }
    return propertyList;
  }
  
  protected void setReadOnly(boolean readOnly)
  {
    this.readOnly = readOnly;
  }
  
  private CSSProperty findCSSProperty(String propertyName)
  {
    for (CSSProperty property : properties) {
      if (CSSPropertyImpl.sameName(property, propertyName)) {
        return property;
      }
    }
    return null;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.e4.ui.css.core.impl.dom.CSSStyleDeclarationImpl
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.e4.ui.css.core.impl.dom;

import java.io.Serializable;
import org.eclipse.e4.ui.css.core.dom.CSSPropertyList;
import org.eclipse.e4.ui.css.core.dom.ExtendedCSSRule;
import org.w3c.css.sac.SelectorList;
import org.w3c.dom.DOMException;
import org.w3c.dom.css.CSSRule;
import org.w3c.dom.css.CSSStyleDeclaration;
import org.w3c.dom.css.CSSStyleRule;
import org.w3c.dom.css.CSSStyleSheet;

public class CSSStyleRuleImpl
  extends CSSRuleImpl
  implements CSSStyleRule, ExtendedCSSRule, Serializable
{
  private SelectorList selectors;
  private CSSStyleDeclarationImpl styleDeclaration;
  
  public CSSStyleRuleImpl(CSSStyleSheet parentStyleSheet, CSSRule parentRule, SelectorList selectors)
  {
    super(parentStyleSheet, parentRule);
    this.selectors = selectors;
  }
  
  public short getType()
  {
    return 1;
  }
  
  public String getSelectorText()
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public CSSStyleDeclaration getStyle()
  {
    return styleDeclaration;
  }
  
  public void setSelectorText(String selectorText)
    throws DOMException
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public SelectorList getSelectorList()
  {
    return selectors;
  }
  
  public CSSPropertyList getCSSPropertyList()
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public void setStyle(CSSStyleDeclarationImpl styleDeclaration)
  {
    this.styleDeclaration = styleDeclaration;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.e4.ui.css.core.impl.dom.CSSStyleRuleImpl
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.e4.ui.css.core.impl.dom;

import java.io.Serializable;
import org.eclipse.e4.ui.css.core.exceptions.DOMExceptionImpl;
import org.w3c.dom.DOMException;
import org.w3c.dom.Node;
import org.w3c.dom.css.CSSRule;
import org.w3c.dom.css.CSSRuleList;
import org.w3c.dom.css.CSSStyleSheet;
import org.w3c.dom.stylesheets.MediaList;
import org.w3c.dom.stylesheets.StyleSheet;

public class CSSStyleSheetImpl
  extends AbstractCSSNode
  implements CSSStyleSheet, Serializable
{
  private CSSRuleList rules = null;
  
  public void deleteRule(int position)
    throws DOMException
  {
    try
    {
      ((CSSRuleListImpl)rules).remove(position);
    }
    catch (IndexOutOfBoundsException ex)
    {
      throw new DOMExceptionImpl((short)1, 1, ex.getMessage());
    }
  }
  
  public CSSRuleList getCssRules()
  {
    return rules;
  }
  
  public CSSRule getOwnerRule()
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public int insertRule(String arg0, int arg1)
    throws DOMException
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public boolean getDisabled()
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public String getHref()
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public MediaList getMedia()
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public Node getOwnerNode()
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public StyleSheet getParentStyleSheet()
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public String getTitle()
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public String getType()
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public void setDisabled(boolean disabled)
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public void setRuleList(CSSRuleList rules)
  {
    this.rules = rules;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.e4.ui.css.core.impl.dom.CSSStyleSheetImpl
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.e4.ui.css.core.impl.dom;

import java.io.Serializable;
import org.w3c.dom.css.CSSRule;
import org.w3c.dom.css.CSSStyleSheet;
import org.w3c.dom.css.CSSUnknownRule;

public class CSSUnknownRuleImpl
  extends CSSRuleImpl
  implements CSSUnknownRule, Serializable
{
  public CSSUnknownRuleImpl(CSSStyleSheet parentStyleSheet, CSSRule parentRule, String atRule)
  {
    super(parentStyleSheet, parentRule);
  }
  
  public short getType()
  {
    return 0;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.e4.ui.css.core.impl.dom.CSSUnknownRuleImpl
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.e4.ui.css.core.impl.dom;

import org.w3c.css.sac.LexicalUnit;
import org.w3c.dom.css.CSSPrimitiveValue;
import org.w3c.dom.css.CSSValue;

public class CSSValueFactory
{
  public static CSSValue newValue(LexicalUnit value)
  {
    if (value.getNextLexicalUnit() != null) {
      return new CSSValueListImpl(value);
    }
    return newPrimitiveValue(value);
  }
  
  public static CSSPrimitiveValue newPrimitiveValue(LexicalUnit value)
  {
    if (value.getLexicalUnitType() == 27) {
      return new RGBColorImpl(value);
    }
    return new Measure(value);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.e4.ui.css.core.impl.dom.CSSValueFactory
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.e4.ui.css.core.impl.dom;

import java.io.Serializable;
import org.eclipse.e4.ui.css.core.exceptions.DOMExceptionImpl;
import org.w3c.dom.DOMException;
import org.w3c.dom.css.CSSPrimitiveValue;
import org.w3c.dom.css.CSSValue;
import org.w3c.dom.css.Counter;
import org.w3c.dom.css.RGBColor;
import org.w3c.dom.css.Rect;

public abstract class CSSValueImpl
  extends AbstractCSSNode
  implements CSSPrimitiveValue, CSSValue, Serializable
{
  public String getCssText()
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public short getCssValueType()
  {
    return 1;
  }
  
  public void setCssText(String cssText)
    throws DOMException
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public short getPrimitiveType()
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public Counter getCounterValue()
    throws DOMException
  {
    throw new DOMExceptionImpl((short)15, 12);
  }
  
  public RGBColor getRGBColorValue()
    throws DOMException
  {
    throw new DOMExceptionImpl((short)15, 14);
  }
  
  public Rect getRectValue()
    throws DOMException
  {
    throw new DOMExceptionImpl((short)15, 13);
  }
  
  public String getStringValue()
    throws DOMException
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public void setFloatValue(short arg0, float arg1)
    throws DOMException
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public void setStringValue(short arg0, String arg1)
    throws DOMException
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
  
  public float getFloatValue(short valueType)
    throws DOMException
  {
    throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
  }
}

/* Location:
 * Qualified Name:     org.eclipse.e4.ui.css.core.impl.dom.CSSValueImpl
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.e4.ui.css.core.impl.dom;

import java.util.ArrayList;
import java.util.List;
import org.w3c.css.sac.LexicalUnit;
import org.w3c.dom.DOMException;
import org.w3c.dom.css.CSSValue;
import org.w3c.dom.css.CSSValueList;

public class CSSValueListImpl
  extends AbstractCSSNode
  implements CSSValueList
{
  List<CSSValue> values;
  
  public CSSValueListImpl(LexicalUnit parsePropertyValue)
  {
    values = new ArrayList();
    
    LexicalUnit unit = parsePropertyValue;
    while (unit != null)
    {
      values.add(CSSValueFactory.newPrimitiveValue(unit));
      unit = unit.getNextL
1 2 3 4 5 6 7 8 9

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2017. Infinite Loop Ltd