org.apache.batik.dom_1.6.0.v201011041432

ic String getNodeName()
  {
    return getTarget();
  }
  
  public short getNodeType()
  {
    return 7;
  }
  
  public String getNodeValue()
    throws DOMException
  {
    return getData();
  }
  
  public void setNodeValue(String paramString)
    throws DOMException
  {
    setData(paramString);
  }
  
  public String getData()
  {
    return data;
  }
  
  public void setData(String paramString)
    throws DOMException
  {
    if (isReadonly()) {
      throw createDOMException((short)7, "readonly.node", new Object[] { new Integer(getNodeType()), getNodeName() });
    }
    String str = data;
    data = paramString;
    fireDOMCharacterDataModifiedEvent(str, data);
    if (getParentNode() != null) {
      ((AbstractParentNode)getParentNode()).fireDOMSubtreeModifiedEvent();
    }
  }
  
  protected Node export(Node paramNode, AbstractDocument paramAbstractDocument)
  {
    AbstractProcessingInstruction localAbstractProcessingInstruction = (AbstractProcessingInstruction)super.export(paramNode, paramAbstractDocument);
    data = data;
    return localAbstractProcessingInstruction;
  }
  
  protected Node deepExport(Node paramNode, AbstractDocument paramAbstractDocument)
  {
    AbstractProcessingInstruction localAbstractProcessingInstruction = (AbstractProcessingInstruction)super.deepExport(paramNode, paramAbstractDocument);
    data = data;
    return localAbstractProcessingInstruction;
  }
  
  protected Node copyInto(Node paramNode)
  {
    AbstractProcessingInstruction localAbstractProcessingInstruction = (AbstractProcessingInstruction)super.copyInto(paramNode);
    data = data;
    return localAbstractProcessingInstruction;
  }
  
  protected Node deepCopyInto(Node paramNode)
  {
    AbstractProcessingInstruction localAbstractProcessingInstruction = (AbstractProcessingInstruction)super.deepCopyInto(paramNode);
    data = data;
    return localAbstractProcessingInstruction;
  }
  
  public abstract String getTarget();
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.AbstractProcessingInstruction
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

import org.apache.batik.css.engine.CSSEngine;
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.DocumentType;
import org.w3c.dom.Element;
import org.w3c.dom.css.CSSStyleDeclaration;
import org.w3c.dom.css.DocumentCSS;
import org.w3c.dom.stylesheets.StyleSheetList;
import org.w3c.dom.views.AbstractView;
import org.w3c.dom.views.DocumentView;

public abstract class AbstractStylableDocument
  extends AbstractDocument
  implements DocumentCSS, DocumentView
{
  protected transient AbstractView defaultView;
  protected transient CSSEngine cssEngine;
  
  protected AbstractStylableDocument() {}
  
  protected AbstractStylableDocument(DocumentType paramDocumentType, DOMImplementation paramDOMImplementation)
  {
    super(paramDocumentType, paramDOMImplementation);
  }
  
  public void setCSSEngine(CSSEngine paramCSSEngine)
  {
    cssEngine = paramCSSEngine;
  }
  
  public CSSEngine getCSSEngine()
  {
    return cssEngine;
  }
  
  public StyleSheetList getStyleSheets()
  {
    throw new RuntimeException(" !!! Not implemented");
  }
  
  public AbstractView getDefaultView()
  {
    if (defaultView == null)
    {
      ExtensibleDOMImplementation localExtensibleDOMImplementation = (ExtensibleDOMImplementation)implementation;
      defaultView = localExtensibleDOMImplementation.createViewCSS(this);
    }
    return defaultView;
  }
  
  public void clearViewCSS()
  {
    defaultView = null;
    if (cssEngine != null) {
      cssEngine.dispose();
    }
    cssEngine = null;
  }
  
  public CSSStyleDeclaration getOverrideStyle(Element paramElement, String paramString)
  {
    throw new RuntimeException(" !!! Not implemented");
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.AbstractStylableDocument
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

import org.w3c.dom.DOMException;
import org.w3c.dom.Node;
import org.w3c.dom.Text;

public abstract class AbstractText
  extends AbstractCharacterData
  implements Text
{
  public Text splitText(int paramInt)
    throws DOMException
  {
    if (isReadonly()) {
      throw createDOMException((short)7, "readonly.node", new Object[] { new Integer(getNodeType()), getNodeName() });
    }
    String str1 = getNodeValue();
    if ((paramInt < 0) || (paramInt >= str1.length())) {
      throw createDOMException((short)1, "offset", new Object[] { new Integer(paramInt) });
    }
    Node localNode1 = getParentNode();
    if (localNode1 == null) {
      throw createDOMException((short)1, "need.parent", new Object[0]);
    }
    String str2 = str1.substring(paramInt);
    Text localText = createTextNode(str2);
    Node localNode2 = getNextSibling();
    if (localNode2 != null) {
      localNode1.insertBefore(localText, localNode2);
    } else {
      localNode1.appendChild(localText);
    }
    setNodeValue(str1.substring(0, paramInt));
    return localText;
  }
  
  protected abstract Text createTextNode(String paramString);
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.AbstractText
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

public abstract interface DomExtension
{
  public abstract float getPriority();
  
  public abstract String getAuthor();
  
  public abstract String getContactAddress();
  
  public abstract String getURL();
  
  public abstract String getDescription();
  
  public abstract void registerTags(ExtensibleDOMImplementation paramExtensibleDOMImplementation);
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.DomExtension
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

import org.apache.batik.dom.events.NodeEventTarget;
import org.w3c.dom.Document;
import org.w3c.dom.Node;

public abstract interface ExtendedNode
  extends Node, NodeEventTarget
{
  public abstract void setNodeName(String paramString);
  
  public abstract boolean isReadonly();
  
  public abstract void setReadonly(boolean paramBoolean);
  
  public abstract void setOwnerDocument(Document paramDocument);
  
  public abstract void setParentNode(Node paramNode);
  
  public abstract void setPreviousSibling(Node paramNode);
  
  public abstract void setNextSibling(Node paramNode);
  
  public abstract void setSpecified(boolean paramBoolean);
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.ExtendedNode
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

import org.w3c.dom.Document;
import org.w3c.dom.Element;

public abstract interface ExtensibleDOMImplementation$ElementFactory
{
  public abstract Element create(String paramString, Document paramDocument);
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.ExtensibleDOMImplementation.ElementFactory
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Locale;
import java.util.MissingResourceException;
import org.apache.batik.css.engine.CSSContext;
import org.apache.batik.css.engine.CSSEngine;
import org.apache.batik.css.engine.value.ShorthandManager;
import org.apache.batik.css.engine.value.ValueManager;
import org.apache.batik.css.parser.ExtendedParser;
import org.apache.batik.css.parser.ExtendedParserWrapper;
import org.apache.batik.dom.util.DOMUtilities;
import org.apache.batik.dom.util.DoublyIndexedTable;
import org.apache.batik.dom.util.HashTable;
import org.apache.batik.i18n.Localizable;
import org.apache.batik.i18n.LocalizableSupport;
import org.apache.batik.util.Service;
import org.apache.batik.util.XMLResourceDescriptor;
import org.w3c.css.sac.Parser;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.css.CSSStyleSheet;
import org.w3c.dom.css.DOMImplementationCSS;
import org.w3c.dom.css.ViewCSS;
import org.w3c.dom.stylesheets.StyleSheet;

public abstract class ExtensibleDOMImplementation
  extends AbstractDOMImplementation
  implements DOMImplementationCSS, StyleSheetFactory, Localizable
{
  protected DoublyIndexedTable customFactories;
  protected List customValueManagers;
  protected List customShorthandManagers;
  protected static final String RESOURCES = "org.apache.batik.dom.resources.Messages";
  protected LocalizableSupport localizableSupport;
  protected static List extensions = null;
  
  public ExtensibleDOMImplementation()
  {
    initLocalizable();
    Iterator localIterator = getDomExtensions().iterator();
    while (localIterator.hasNext())
    {
      DomExtension localDomExtension = (DomExtension)localIterator.next();
      localDomExtension.registerTags(this);
    }
  }
  
  public void setLocale(Locale paramLocale)
  {
    localizableSupport.setLocale(paramLocale);
  }
  
  public Locale getLocale()
  {
    return localizableSupport.getLocale();
  }
  
  protected void initLocalizable()
  {
    localizableSupport = new LocalizableSupport("org.apache.batik.dom.resources.Messages", getClass().getClassLoader());
  }
  
  public String formatMessage(String paramString, Object[] paramArrayOfObject)
    throws MissingResourceException
  {
    return localizableSupport.formatMessage(paramString, paramArrayOfObject);
  }
  
  public void registerCustomElementFactory(String paramString1, String paramString2, ElementFactory paramElementFactory)
  {
    if (customFactories == null) {
      customFactories = new DoublyIndexedTable();
    }
    customFactories.put(paramString1, paramString2, paramElementFactory);
  }
  
  public void registerCustomCSSValueManager(ValueManager paramValueManager)
  {
    if (customValueManagers == null) {
      customValueManagers = new LinkedList();
    }
    customValueManagers.add(paramValueManager);
  }
  
  public void registerCustomCSSShorthandManager(ShorthandManager paramShorthandManager)
  {
    if (customShorthandManagers == null) {
      customShorthandManagers = new LinkedList();
    }
    customShorthandManagers.add(paramShorthandManager);
  }
  
  public CSSEngine createCSSEngine(AbstractStylableDocument paramAbstractStylableDocument, CSSContext paramCSSContext)
  {
    String str = XMLResourceDescriptor.getCSSParserClassName();
    Parser localParser;
    try
    {
      localParser = (Parser)Class.forName(str).newInstance();
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
      throw new DOMException((short)15, formatMessage("css.parser.class", new Object[] { str }));
    }
    catch (InstantiationException localInstantiationException)
    {
      throw new DOMException((short)15, formatMessage("css.parser.creation", new Object[] { str }));
    }
    catch (IllegalAccessException localIllegalAccessException)
    {
      throw new DOMException((short)15, formatMessage("css.parser.access", new Object[] { str }));
    }
    ExtendedParser localExtendedParser = ExtendedParserWrapper.wrap(localParser);
    ValueManager[] arrayOfValueManager;
    Object localObject1;
    if (customValueManagers == null)
    {
      arrayOfValueManager = new ValueManager[0];
    }
    else
    {
      arrayOfValueManager = new ValueManager[customValueManagers.size()];
      localObject1 = customValueManagers.iterator();
      int i = 0;
      while (((Iterator)localObject1).hasNext()) {
        arrayOfValueManager[(i++)] = ((ValueManager)((Iterator)localObject1).next());
      }
    }
    if (customShorthandManagers == null)
    {
      localObject1 = new ShorthandManager[0];
    }
    else
    {
      localObject1 = new ShorthandManager[customShorthandManagers.size()];
      localObject2 = customShorthandManagers.iterator();
      int j = 0;
      while (((Iterator)localObject2).hasNext()) {
        localObject1[(j++)] = ((ShorthandManager)((Iterator)localObject2).next());
      }
    }
    Object localObject2 = createCSSEngine(paramAbstractStylableDocument, paramCSSContext, localExtendedParser, arrayOfValueManager, (ShorthandManager[])localObject1);
    paramAbstractStylableDocument.setCSSEngine((CSSEngine)localObject2);
    return (CSSEngine)localObject2;
  }
  
  public abstract CSSEngine createCSSEngine(AbstractStylableDocument paramAbstractStylableDocument, CSSContext paramCSSContext, ExtendedParser paramExtendedParser, ValueManager[] paramArrayOfValueManager, ShorthandManager[] paramArrayOfShorthandManager);
  
  public abstract ViewCSS createViewCSS(AbstractStylableDocument paramAbstractStylableDocument);
  
  public Element createElementNS(AbstractDocument paramAbstractDocument, String paramString1, String paramString2)
  {
    if (paramString1 == null) {
      return new GenericElement(paramString2.intern(), paramAbstractDocument);
    }
    if (customFactories != null)
    {
      String str = DOMUtilities.getLocalName(paramString2);
      ElementFactory localElementFactory = (ElementFactory)customFactories.get(paramString1, str);
      if (localElementFactory != null) {
        return localElementFactory.create(DOMUtilities.getPrefix(paramString2), paramAbstractDocument);
      }
    }
    return new GenericElementNS(paramString1.intern(), paramString2.intern(), paramAbstractDocument);
  }
  
  protected static synchronized List getDomExtensions()
  {
    if (extensions != null) {
      return extensions;
    }
    extensions = new LinkedList();
    Iterator localIterator = Service.providers(DomExtension.class);
    while (localIterator.hasNext())
    {
      DomExtension localDomExtension1 = (DomExtension)localIterator.next();
      float f = localDomExtension1.getPriority();
      ListIterator localListIterator = extensions.listIterator();
      DomExtension localDomExtension2;
      do
      {
        if (!localListIterator.hasNext())
        {
          localListIterator.add(localDomExtension1);
          break;
        }
        localDomExtension2 = (DomExtension)localListIterator.next();
      } while (localDomExtension2.getPriority() <= f);
      localListIterator.previous();
      localListIterator.add(localDomExtension1);
    }
    return extensions;
  }
  
  public abstract CSSStyleSheet createCSSStyleSheet(String paramString1, String paramString2)
    throws DOMException;
  
  public abstract StyleSheet createStyleSheet(Node paramNode, HashTable paramHashTable);
  
  public static abstract interface ElementFactory
  {
    public abstract Element create(String paramString, Document paramDocument);
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.ExtensibleDOMImplementation
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

import org.w3c.dom.DOMException;
import org.w3c.dom.Node;

public class GenericAttr
  extends AbstractAttr
{
  protected boolean readonly;
  
  protected GenericAttr() {}
  
  public GenericAttr(String paramString, AbstractDocument paramAbstractDocument)
    throws DOMException
  {
    super(paramString, paramAbstractDocument);
    setNodeName(paramString);
  }
  
  public boolean isReadonly()
  {
    return readonly;
  }
  
  public void setReadonly(boolean paramBoolean)
  {
    readonly = paramBoolean;
  }
  
  protected Node newNode()
  {
    return new GenericAttr();
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.GenericAttr
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

import org.w3c.dom.DOMException;
import org.w3c.dom.Node;

public class GenericAttrNS
  extends AbstractAttrNS
{
  protected boolean readonly;
  
  protected GenericAttrNS() {}
  
  public GenericAttrNS(String paramString1, String paramString2, AbstractDocument paramAbstractDocument)
    throws DOMException
  {
    super(paramString1, paramString2, paramAbstractDocument);
    setNodeName(paramString2);
  }
  
  public boolean isReadonly()
  {
    return readonly;
  }
  
  public void setReadonly(boolean paramBoolean)
  {
    readonly = paramBoolean;
  }
  
  protected Node newNode()
  {
    return new GenericAttrNS();
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.GenericAttrNS
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

import org.w3c.dom.CDATASection;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.Text;

public class GenericCDATASection
  extends AbstractText
  implements CDATASection
{
  protected boolean readonly;
  
  protected GenericCDATASection() {}
  
  public GenericCDATASection(String paramString, AbstractDocument paramAbstractDocument)
  {
    ownerDocument = paramAbstractDocument;
    setNodeValue(paramString);
  }
  
  public String getNodeName()
  {
    return "#cdata-section";
  }
  
  public short getNodeType()
  {
    return 4;
  }
  
  public boolean isReadonly()
  {
    return readonly;
  }
  
  public void setReadonly(boolean paramBoolean)
  {
    readonly = paramBoolean;
  }
  
  protected Text createTextNode(String paramString)
  {
    return getOwnerDocument().createCDATASection(paramString);
  }
  
  protected Node newNode()
  {
    return new GenericCDATASection();
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.GenericCDATASection
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

import org.w3c.dom.Node;

public class GenericComment
  extends AbstractComment
{
  protected boolean readonly;
  
  public GenericComment() {}
  
  public GenericComment(String paramString, AbstractDocument paramAbstractDocument)
  {
    ownerDocument = paramAbstractDocument;
    setNodeValue(paramString);
  }
  
  public boolean isReadonly()
  {
    return readonly;
  }
  
  public void setReadonly(boolean paramBoolean)
  {
    readonly = paramBoolean;
  }
  
  protected Node newNode()
  {
    return new GenericComment();
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.GenericComment
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

import org.w3c.dom.DOMException;
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.Document;
import org.w3c.dom.DocumentType;
import org.w3c.dom.Node;

public class GenericDOMImplementation
  extends AbstractDOMImplementation
{
  protected static final DOMImplementation DOM_IMPLEMENTATION = new GenericDOMImplementation();
  
  public static DOMImplementation getDOMImplementation()
  {
    return DOM_IMPLEMENTATION;
  }
  
  public DocumentType createDocumentType(String paramString1, String paramString2, String paramString3)
  {
    throw new DOMException((short)9, "Doctype not supported");
  }
  
  public Document createDocument(String paramString1, String paramString2, DocumentType paramDocumentType)
    throws DOMException
  {
    GenericDocument localGenericDocument = new GenericDocument(paramDocumentType, this);
    localGenericDocument.appendChild(localGenericDocument.createElementNS(paramString1, paramString2));
    return localGenericDocument;
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.GenericDOMImplementation
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

import org.w3c.dom.Attr;
import org.w3c.dom.CDATASection;
import org.w3c.dom.Comment;
import org.w3c.dom.DOMException;
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.DocumentFragment;
import org.w3c.dom.DocumentType;
import org.w3c.dom.Element;
import org.w3c.dom.EntityReference;
import org.w3c.dom.Node;
import org.w3c.dom.ProcessingInstruction;
import org.w3c.dom.Text;

public class GenericDocument
  extends AbstractDocument
{
  protected static final String ATTR_ID = "id";
  protected boolean readonly;
  
  protected GenericDocument() {}
  
  public GenericDocument(DocumentType paramDocumentType, DOMImplementation paramDOMImplementation)
  {
    super(paramDocumentType, paramDOMImplementation);
  }
  
  public boolean isReadonly()
  {
    return readonly;
  }
  
  public void setReadonly(boolean paramBoolean)
  {
    readonly = paramBoolean;
  }
  
  public boolean isId(Attr paramAttr)
  {
    if (paramAttr.getNamespaceURI() != null) {
      return false;
    }
    return "id".equals(paramAttr.getNodeName());
  }
  
  public Element createElement(String paramString)
    throws DOMException
  {
    return new GenericElement(paramString.intern(), this);
  }
  
  public DocumentFragment createDocumentFragment()
  {
    return new GenericDocumentFragment(this);
  }
  
  public Text createTextNode(String paramString)
  {
    return new GenericText(paramString, this);
  }
  
  public Comment createComment(String paramString)
  {
    return new GenericComment(paramString, this);
  }
  
  public CDATASection createCDATASection(String paramString)
    throws DOMException
  {
    return new GenericCDATASection(paramString, this);
  }
  
  public ProcessingInstruction createProcessingInstruction(String paramString1, String paramString2)
    throws DOMException
  {
    return new GenericProcessingInstruction(paramString1, paramString2, this);
  }
  
  public Attr createAttribute(String paramString)
    throws DOMException
  {
    return new GenericAttr(paramString.intern(), this);
  }
  
  public EntityReference createEntityReference(String paramString)
    throws DOMException
  {
    return new GenericEntityReference(paramString, this);
  }
  
  public Element createElementNS(String paramString1, String paramString2)
    throws DOMException
  {
    if (paramString1 == null) {
      return new GenericElement(paramString2.intern(), this);
    }
    return new GenericElementNS(paramString1.intern(), paramString2.intern(), this);
  }
  
  public Attr createAttributeNS(String paramString1, String paramString2)
    throws DOMException
  {
    if (paramString1 == null) {
      return new GenericAttr(paramString2.intern(), this);
    }
    return new GenericAttrNS(paramString1.intern(), paramString2.intern(), this);
  }
  
  protected Node newNode()
  {
    return new GenericDocument();
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.GenericDocument
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

import org.w3c.dom.Node;

public class GenericDocumentFragment
  extends AbstractDocumentFragment
{
  protected boolean readonly;
  
  protected GenericDocumentFragment() {}
  
  public GenericDocumentFragment(AbstractDocument paramAbstractDocument)
  {
    ownerDocument = paramAbstractDocument;
  }
  
  public boolean isReadonly()
  {
    return readonly;
  }
  
  public void setReadonly(boolean paramBoolean)
  {
    readonly = paramBoolean;
  }
  
  protected Node newNode()
  {
    return new GenericDocumentFragment();
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.GenericDocumentFragment
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

import org.w3c.dom.DocumentType;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;

public class GenericDocumentType
  extends AbstractChildNode
  implements DocumentType
{
  protected String qualifiedName;
  protected String publicId;
  protected String systemId;
  
  public GenericDocumentType(String paramString1, String paramString2, String paramString3)
  {
    qualifiedName = paramString1;
    publicId = paramString2;
    systemId = paramString3;
  }
  
  public String getNodeName()
  {
    return qualifiedName;
  }
  
  public short getNodeType()
  {
    return 10;
  }
  
  public boolean isReadonly()
  {
    return true;
  }
  
  public void setReadonly(boolean paramBoolean) {}
  
  public String getName()
  {
    return null;
  }
  
  public NamedNodeMap getEntities()
  {
    return null;
  }
  
  public NamedNodeMap getNotations()
  {
    return null;
  }
  
  public String getPublicId()
  {
    return publicId;
  }
  
  public String getSystemId()
  {
    return systemId;
  }
  
  public String getInternalSubset()
  {
    return null;
  }
  
  protected Node newNode()
  {
    return new GenericDocumentType(qualifiedName, publicId, systemId);
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.GenericDocumentType
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

import org.w3c.dom.DOMException;
import org.w3c.dom.Node;

public class GenericElement
  extends AbstractElement
{
  protected String nodeName;
  protected boolean readonly;
  
  protected GenericElement() {}
  
  public GenericElement(String paramString, AbstractDocument paramAbstractDocument)
    throws DOMException
  {
    super(paramString, paramAbstractDocument);
    nodeName = paramString;
  }
  
  public void setNodeName(String paramString)
  {
    nodeName = paramString;
  }
  
  public String getNodeName()
  {
    return nodeName;
  }
  
  public boolean isReadonly()
  {
    return readonly;
  }
  
  public void setReadonly(boolean paramBoolean)
  {
    readonly = paramBoolean;
  }
  
  protected Node export(Node paramNode, AbstractDocument paramAbstractDocument)
  {
    super.export(paramNode, paramAbstractDocument);
    GenericElement localGenericElement = (GenericElement)paramNode;
    nodeName = nodeName;
    return paramNode;
  }
  
  protected Node deepExport(Node paramNode, AbstractDocument paramAbstractDocument)
  {
    super.deepExport(paramNode, paramAbstractDocument);
    GenericElement localGenericElement = (GenericElement)paramNode;
    nodeName = nodeName;
    return paramNode;
  }
  
  protected Node copyInto(Node paramNode)
  {
    GenericElement localGenericElement = (GenericElement)super.copyInto(paramNode);
    nodeName = nodeName;
    return paramNode;
  }
  
  protected Node deepCopyInto(Node paramNode)
  {
    GenericElement localGenericElement = (GenericElement)super.deepCopyInto(paramNode);
    nodeName = nodeName;
    return paramNode;
  }
  
  protected Node newNode()
  {
    return new GenericElement();
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.GenericElement
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

import org.w3c.dom.Node;

public class GenericElementNS
  extends AbstractElementNS
{
  protected String nodeName;
  protected boolean readonly;
  
  protected GenericElementNS() {}
  
  public GenericElementNS(String paramString1, String paramString2, AbstractDocument paramAbstractDocument)
  {
    super(paramString1, paramString2, paramAbstractDocument);
    nodeName = paramString2;
  }
  
  public void setNodeName(String paramString)
  {
    nodeName = paramString;
  }
  
  public String getNodeName()
  {
    return nodeName;
  }
  
  public boolean isReadonly()
  {
    return readonly;
  }
  
  public void setReadonly(boolean paramBoolean)
  {
    readonly = paramBoolean;
  }
  
  protected Node export(Node paramNode, AbstractDocument paramAbstractDocument)
  {
    GenericElementNS localGenericElementNS = (GenericElementNS)super.export(paramNode, paramAbstractDocument);
    nodeName = nodeName;
    return paramNode;
  }
  
  protected Node deepExport(Node paramNode, AbstractDocument paramAbstractDocument)
  {
    GenericElementNS localGenericElementNS = (GenericElementNS)super.deepExport(paramNode, paramAbstractDocument);
    nodeName = nodeName;
    return paramNode;
  }
  
  protected Node copyInto(Node paramNode)
  {
    GenericElementNS localGenericElementNS = (GenericElementNS)super.copyInto(paramNode);
    nodeName = nodeName;
    return paramNode;
  }
  
  protected Node deepCopyInto(Node paramNode)
  {
    GenericElementNS localGenericElementNS = (GenericElementNS)super.deepCopyInto(paramNode);
    nodeName = nodeName;
    return paramNode;
  }
  
  protected Node newNode()
  {
    return new GenericElementNS();
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.GenericElementNS
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

import org.w3c.dom.Node;

public class GenericEntity
  extends AbstractEntity
{
  protected boolean readonly;
  
  protected GenericEntity() {}
  
  public GenericEntity(String paramString1, String paramString2, String paramString3, AbstractDocument paramAbstractDocument)
  {
    ownerDocument = paramAbstractDocument;
    setNodeName(paramString1);
    setPublicId(paramString2);
    setSystemId(paramString3);
  }
  
  public boolean isReadonly()
  {
    return readonly;
  }
  
  public void setReadonly(boolean paramBoolean)
  {
    readonly = paramBoolean;
  }
  
  protected Node newNode()
  {
    return new GenericEntity();
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.GenericEntity
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

import org.w3c.dom.Node;

public class GenericEntityReference
  extends AbstractEntityReference
{
  protected boolean readonly;
  
  protected GenericEntityReference() {}
  
  public GenericEntityReference(String paramString, AbstractDocument paramAbstractDocument)
  {
    super(paramString, paramAbstractDocument);
  }
  
  public boolean isReadonly()
  {
    return readonly;
  }
  
  public void setReadonly(boolean paramBoolean)
  {
    readonly = paramBoolean;
  }
  
  protected Node newNode()
  {
    return new GenericEntityReference();
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.GenericEntityReference
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

import org.w3c.dom.Node;

public class GenericNotation
  extends AbstractNotation
{
  protected boolean readonly;
  
  protected GenericNotation() {}
  
  public GenericNotation(String paramString1, String paramString2, String paramString3, AbstractDocument paramAbstractDocument)
  {
    ownerDocument = paramAbstractDocument;
    setNodeName(paramString1);
    setPublicId(paramString2);
    setSystemId(paramString3);
  }
  
  public boolean isReadonly()
  {
    return readonly;
  }
  
  public void setReadonly(boolean paramBoolean)
  {
    readonly = paramBoolean;
  }
  
  protected Node newNode()
  {
    return new GenericNotation();
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.GenericNotation
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

import org.w3c.dom.Node;

public class GenericProcessingInstruction
  extends AbstractProcessingInstruction
{
  protected String target;
  protected boolean readonly;
  
  protected GenericProcessingInstruction() {}
  
  public GenericProcessingInstruction(String paramString1, String paramString2, AbstractDocument paramAbstractDocument)
  {
    ownerDocument = paramAbstractDocument;
    setTarget(paramString1);
    setData(paramString2);
  }
  
  public void setNodeName(String paramString)
  {
    setTarget(paramString);
  }
  
  public boolean isReadonly()
  {
    return readonly;
  }
  
  public void setReadonly(boolean paramBoolean)
  {
    readonly = paramBoolean;
  }
  
  public String getTarget()
  {
    return target;
  }
  
  public void setTarget(String paramString)
  {
    target = paramString;
  }
  
  protected Node export(Node paramNode, AbstractDocument paramAbstractDocument)
  {
    GenericProcessingInstruction localGenericProcessingInstruction = (GenericProcessingInstruction)super.export(paramNode, paramAbstractDocument);
    localGenericProcessingInstruction.setTarget(getTarget());
    return localGenericProcessingInstruction;
  }
  
  protected Node deepExport(Node paramNode, AbstractDocument paramAbstractDocument)
  {
    GenericProcessingInstruction localGenericProcessingInstruction = (GenericProcessingInstruction)super.deepExport(paramNode, paramAbstractDocument);
    localGenericProcessingInstruction.setTarget(getTarget());
    return localGenericProcessingInstruction;
  }
  
  protected Node copyInto(Node paramNode)
  {
    GenericProcessingInstruction localGenericProcessingInstruction = (GenericProcessingInstruction)super.copyInto(paramNode);
    localGenericProcessingInstruction.setTarget(getTarget());
    return localGenericProcessingInstruction;
  }
  
  protected Node deepCopyInto(Node paramNode)
  {
    GenericProcessingInstruction localGenericProcessingInstruction = (GenericProcessingInstruction)super.deepCopyInto(paramNode);
    localGenericProcessingInstruction.setTarget(getTarget());
    return localGenericProcessingInstruction;
  }
  
  protected Node newNode()
  {
    return new GenericProcessingInstruction();
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.GenericProcessingInstruction
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.Text;

public class GenericText
  extends AbstractText
{
  protected boolean readonly;
  
  protected GenericText() {}
  
  public GenericText(String paramString, AbstractDocument paramAbstractDocument)
  {
    ownerDocument = paramAbstractDocument;
    setNodeValue(paramString);
  }
  
  public String getNodeName()
  {
    return "#text";
  }
  
  public short getNodeType()
  {
    return 3;
  }
  
  public boolean isReadonly()
  {
    return readonly;
  }
  
  public void setReadonly(boolean paramBoolean)
  {
    readonly = paramBoolean;
  }
  
  protected Text createTextNode(String paramString)
  {
    return getOwnerDocument().createTextNode(paramString);
  }
  
  protected Node newNode()
  {
    return new GenericText();
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.GenericText
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

import org.apache.batik.dom.util.HashTable;
import org.w3c.dom.Node;
import org.w3c.dom.stylesheets.StyleSheet;

public abstract interface StyleSheetFactory
{
  public abstract StyleSheet createStyleSheet(Node paramNode, HashTable paramHashTable);
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.StyleSheetFactory
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom;

import org.apache.batik.dom.util.DOMUtilities;
import org.apache.batik.dom.util.HashTable;
import org.w3c.dom.DOMException;
import org.w3c.dom.Node;
import org.w3c.dom.stylesheets.LinkStyle;
import org.w3c.dom.stylesheets.StyleSheet;

public class StyleSheetProcessingInstruction
  extends AbstractProcessingInstruction
  implements LinkStyle
{
  protected boolean readonly;
  protected transient StyleSheet sheet;
  protected StyleSheetFactory factory;
  protected transient HashTable pseudoAttributes;
  
  protected StyleSheetProcessingInstruction() {}
  
  public StyleSheetProcessingInstruction(String paramString, AbstractDocument paramAbstractDocument, StyleSheetFactory paramStyleSheetFactory)
  {
    ownerDocument = paramAbstractDocument;
    setData(paramString);
    factory = paramStyleSheetFactory;
  }
  
  public boolean isReadonly()
  {
    return readonly;
  }
  
  public void setReadonly(boolean paramBoolean)
  {
    readonly = paramBoolean;
  }
  
  public void setNodeName(String paramString) {}
  
  public String getTarget()
  {
    return "xml-stylesheet";
  }
  
  public StyleSheet getSheet()
  {
    if (sheet == null) {
      sheet = factory.createStyleSheet(this, getPseudoAttributes());
    }
    return sheet;
  }
  
  public HashTable getPseudoAttributes()
  {
    if (pseudoAttributes == null)
    {
      pseudoAttributes = new HashTable();
      pseudoAttributes.put("alternate", "no");
      pseudoAttributes.put("media", "all");
      DOMUtilities.parseStyleSheetPIData(data, pseudoAttributes);
    }
    return pseudoAttributes;
  }
  
  public void setData(String paramString)
    throws DOMException
  {
    super.setData(paramString);
    sheet = null;
    pseudoAttributes = null;
  }
  
  protected Node newNode()
  {
    return new StyleSheetProcessingInstruction();
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.StyleSheetProcessingInstruction
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom.events;

import org.w3c.dom.events.Event;
import org.w3c.dom.events.EventTarget;

public abstract class AbstractEvent
  implements Event
{
  protected String type;
  protected boolean isBubbling;
  protected boolean cancelable;
  protected EventTarget currentTarget;
  protected EventTarget target;
  protected short eventPhase;
  protected long timeStamp = System.currentTimeMillis();
  protected boolean stopPropagation = false;
  protected boolean preventDefault = false;
  
  public String getType()
  {
    return type;
  }
  
  public EventTarget getCurrentTarget()
  {
    return currentTarget;
  }
  
  public EventTarget getTarget()
  {
    return target;
  }
  
  public short getEventPhase()
  {
    return eventPhase;
  }
  
  public boolean getBubbles()
  {
    return isBubbling;
  }
  
  public boolean getCancelable()
  {
    return cancelable;
  }
  
  public long getTimeStamp()
  {
    return timeStamp;
  }
  
  public void stopPropagation()
  {
    stopPropagation = true;
  }
  
  public void preventDefault()
  {
    preventDefault = true;
  }
  
  public void initEvent(String paramString, boolean paramBoolean1, boolean paramBoolean2)
  {
    type = paramString;
    isBubbling = paramBoolean1;
    cancelable = paramBoolean2;
  }
  
  boolean getPreventDefault()
  {
    return preventDefault;
  }
  
  boolean getStopPropagation()
  {
    return stopPropagation;
  }
  
  void setEventPhase(short paramShort)
  {
    eventPhase = paramShort;
  }
  
  void stopPropagation(boolean paramBoolean)
  {
    stopPropagation = paramBoolean;
  }
  
  void preventDefault(boolean paramBoolean)
  {
    preventDefault = paramBoolean;
  }
  
  void setCurrentTarget(EventTarget paramEventTarget)
  {
    currentTarget = paramEventTarget;
  }
  
  void setTarget(EventTarget paramEventTarget)
  {
    target = paramEventTarget;
  }
  
  public static boolean getEventPreventDefault(Event paramEvent)
  {
    AbstractEvent localAbstractEvent = (AbstractEvent)paramEvent;
    return localAbstractEvent.getPreventDefault();
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.dom.events.AbstractEvent
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom.events;

public class DOMEvent
  extends AbstractEvent
{}

/* Location:
 * Qualified Name:     org.apache.batik.dom.events.DOMEvent
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.dom.events;

import org.w3c.dom.views.AbstractView;

public class DOMKeyEvent
  extends DOMUIEvent
{
  public static final int CHAR_UNDEFINED = 65535;
  public static final int DOM_VK_0 = 48;
  public static final int DOM_VK_1 = 49;
  public static final int DOM_VK_2 = 50;
  public static final int DOM_VK_3 = 51;
  public static final int DOM_VK_4 = 52;
  public static final int DOM_VK_5 = 53;
  public static final int DOM_VK_6 = 54;
  public static final int DOM_VK_7 = 55;
  public static final int DOM_VK_8 = 56;
  public static final int DOM_VK_9 = 57;
  public static final int DOM_VK_A = 65;
  public static final int DOM_VK_ACCEPT = 30;
  public static final int DOM_VK_ADD = 107;
  public static final int DOM_VK_AGAIN = 65481;
  public static final int DOM_VK_ALL_CANDIDATES = 256;
  public static final int DOM_VK_ALPHANUMERIC = 240;
  public static final int DOM_VK_ALT = 18;
  public static final int DOM_VK_ALT_GRAPH = 65406;
  public static final int DOM_VK_AMPERSAND = 150;
  public static final int DOM_VK_ASTERISK = 151;
  public static final int DOM_VK_AT = 512;
  public static final int DOM_VK_B = 66;
  public static final int DOM_VK_BACK_QUOTE = 192;
  public static final int DOM_VK_BACK_SLASH = 92;
  public static final int DOM_VK_BACK_SPACE = 8;
  public static final i
1 2 3 4 5 6 7

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-2019. Infinite Loop Ltd