netbeans

looks.nbm

manifest-subst.mf

Info

LooksAPIs

LooksAPIs.zip

javadoc

<?xml version="1.0" encoding="UTF-8"?> <!-- -*- sgml-indent-step: 2 -*- -->

<!--

                Sun Public License Notice

The contents of this file are subject to the Sun Public License

Version 1.0 (the "License"). You may not use this file except in

compliance with the License. A copy of the License is available at

http://www.sun.com/

The Original Code is NetBeans. The Initial Developer of the Original

Code is Sun Microsystems, Inc. Portions Copyright 1997-2003 Sun

Microsystems, Inc. All Rights Reserved.

-->

<project name="looks" default="netbeans" basedir=".">

    <import file="../../nbbuild/default.xml"/> 

    <target name="init" depends="default.init">

        <patternset id="looks.files">

            <include name="${nb.modules/autoload.dir}/looks.jar"/>

        </patternset>

        <path id="cp">

            <pathelement location="../../openide/openide-13javac-workaround.jar"/>

	         <pathelement location="${core/naming.dir}/${nb.modules/autoload.dir}/naming.jar"/>

            <pathelement location="${openide.dir}/${nb.lib.dir}/openide.jar"/>

            <pathelement location="${openide/loaders.dir}/${nb.lib.dir}/openide-loaders.jar"/>

        </path>

    </target>

  <target name="compile" depends="init">

    <javac srcdir="src" destdir="src" deprecation="${build.compiler.deprecation}" debug="${build.compiler.debug}">

      <classpath refid="cp"/>

    </javac>

  </target>

  <target name="jars" depends="compile">

    <mkdir dir="${netbeans.dest.dir}/${cluster.dir}/${nb.modules/autoload.dir}"/>

    <filter token="BUILD_NUMBER_SUBST" value="${buildnumber}"/>

    <copy file="manifest.mf" tofile="manifest-subst.mf" filtering="on"/>

    <jar jarfile="${netbeans.dest.dir}/${cluster.dir}/${nb.modules/autoload.dir}/looks.jar"

         manifest="manifest-subst.mf"

         basedir="src"

	      excludesfile="../../nbbuild/standard-jar-excludes.txt"

	      compress="false">

    </jar>

  </target>

  <target name="netbeans" depends="jars" description="Build everything.">

    <genlist outputfiledir="${netbeans.dest.dir}/${cluster.dir}" module="${nb.modules/autoload.dir}/looks.jar">

      <fileset dir="${netbeans.dest.dir}/${cluster.dir}">

        <include name="${nb.modules/autoload.dir}/looks.jar"/>

      </fileset>

    </genlist>

  </target>

  <target name="nbm" depends="netbeans" description="Build a distributable NBM.">

    <makenbm file="looks.nbm"

             productdir="${netbeans.dest.dir}/${cluster.dir}"

             module="${nb.modules/autoload.dir}/looks.jar"

             homepage="http://openidex.${homepage.base}/"

             distribution="http://${dist.base}/looks.nbm">

      <license file="${license.file}"/>

      <signature keystore="${keystore}" storepass="${storepass}" alias="${nbm_alias}"/>

    </makenbm>

  </target>

  <target name="clean" depends="init" description="Clean all build products.">

    <delete>

      <fileset dir="src">

        <include name="**/*.class"/>

      </fileset>

      <fileset dir="${netbeans.dest.dir}/${cluster.dir}">

        <patternset refID="looks.files"/>

      </fileset>

    </delete>

    <delete file="manifest-subst.mf"/>

    <delete file="looks.nbm"/>

    <delete dir="netbeans"/>

    <delete dir="Info"/>

    <delete dir="javadoc"/>

    <delete dir="LooksAPIs"/>

    <delete file="LooksAPIs.zip"/>

  </target>

  <!-- api changes documentation -->

  <target name="apichanges-check" description="Check syntax of API changes list. Requires Ant 1.4!">

      <xmlvalidate file="api/doc/changes/apichanges.xml" failonerror="true"/>

  </target>

  <target name="apichanges-generate" description="Regenerate HTML from XML API changes list.">

      <!-- Ant 1.3 and 1.4 disagree on style attribute. -->

      <!-- 1.3: treated as a name relative to XML file. -->

      <!-- 1.4: treated as a filename consistent with normal Ant usage. -->

      <!-- Be safe and give the absolute path here. -->

      <style in="api/doc/changes/apichanges.xml" out="../www/proposals/looks/apichanges.html" destdir="www" style="${basedir}/../../openide/api/doc/changes/apichanges.xsl"/>

  </target>

  <target name="javadoc" depends="looks-apis">

    <copy todir="javadoc">

      <fileset dir=".">

        <include name="LooksAPIs/**"/>

        <include name="LooksAPIs.zip"/>

      </fileset>

    </copy>

  </target>

  <!-- Looks API documentation -->

  <target name="looks-apis" description="Create Looks API documentation.">

    <property name="jdk-docs-location" value="http://java.sun.com/j2se/1.3/docs/api"/>

    <property name="openide-docs-location" value="http://www.netbeans.org/download/apis/"/>

    <property name="openide.package-list.loc" location="${nbroot}/openide/OpenAPIs"/>

    <echo message="Build Looks API documentation..."/>

    <delete dir="LooksAPIs"/>

    <mkdir dir="LooksAPIs"/>

    <javadoc destdir="LooksAPIs"

             packagenames="org.netbeans.api.*,org.netbeans.spi.*"

             doctitle="NetBeans Looks APIs"

             use="true"

             splitindex="true"

             author="false"

             version="false"

             maxmemory="64m"

    >

      <sourcepath>

        <pathelement location="api/doc"/>

        <pathelement location="src"/>

      </sourcepath>

      <classpath>

        <fileset dir="${nbroot}/openide/netbeans/lib">

          <include name="openide*.jar" />

        </fileset>

	<pathelement location="../../core/naming/netbeans/modules/autoload/naming.jar"/>

      </classpath>

      <link href="${jdk-docs-location}"

            offline="true"

            packagelistLoc="${nbroot}/openide/api/doc"

      />

      <link href="${openide-docs-location}"

            offline="true"

            packagelistLoc="${openide.package-list.loc}"

      />

    </javadoc>

    <zip zipfile="LooksAPIs.zip" basedir="LooksAPIs"/>

  </target>

</project>

Manifest-Version: 1.0

OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/looks/Bundle.properties

OpenIDE-Module-Specification-Version: 1.1

_OpenIDE-Module-IDE-Dependencies: IDE/1 > 1.24

OpenIDE-Module: org.netbeans.modules.looks/1

OpenIDE-Module-Layer: org/netbeans/modules/looks/mf-layer.xml

OpenIDE-Module-Implementation-Version: @BUILD_NUMBER_SUBST@

OpenIDE-Module-Module-Dependencies: org.netbeans.core.naming/1 > 1.1

OpenIDE-Module-Deprecated: true

<?xml version="1.0" encoding="UTF-8"?><!-- -*- sgml-indent-step: 2 -*- -->

<!--

   -                 Sun Public License Notice

   - 

   - The contents of this file are subject to the Sun Public License

   - Version 1.0 (the "License"). You may not use this file except in

   - compliance with the License. A copy of the License is available at

   - http://www.sun.com/

   - 

   - The Original Code is NetBeans. The Initial Developer of the Original

   - Code is Sun Microsystems, Inc. Portions Copyright 1997-2002 Sun

   - Microsystems, Inc. All Rights Reserved.

  -->

<?xml-stylesheet type="text/xml" href="../../../../../openide/api/doc/changes/apichanges.xsl"?>

<!DOCTYPE apichanges PUBLIC 

	"-//NetBeans//DTD API changes list 1.0//EN" 

        "../../../../../openide/api/doc/changes/apichanges.dtd"

>

<!--

INFO FOR PEOPLE ADDING CHANGES:

Check the DTD (apichanges.dtd) for details on the syntax. You do not

need to regenerate the HTML, this will be done periodically; just

change the XML. If you can, validate the XML against the DTD, if not

do not worry about it. Rough syntax of a change (several parts optional):

<change>

    <api name="compiler"/>

    <summary>Some brief description here, can use <b>XHTML</b></summary>

    <version major="1" minor="99"/>

    <date day="13" month="6" year="2001"/>

    <author login="jrhacker"/>

    <compatibility addition="yes"/>

    <description>

        The main description of the change here.

        Again can use full <b>XHTML</b> as needed.

    </description>

    <class package="org.openide.compiler" name="DoWhatIWantCompiler"/>

    <issue number="14309"/>

</change>

Also permitted elements: <package>, <branch>. <version> is API spec

version, recommended for all new changes. <compatibility> should say

if things were added/modified/deprecated/etc. and give all information

related to upgrading old code. List affected top-level classes and

link to issue numbers if applicable. See the DTD for more details.

Changes need not be in any particular order, they are sorted in various

ways by the stylesheet anyway.

Dates are assumed to mean "on the trunk". If you *also* make the same

change on a stabilization branch, use the <branch> tag to indicate this

and explain why the change was made on a branch in the <description>.

Please only change this file on the trunk! Rather: you can change it

on branches if you want, but these changes will be ignored; only the

trunk version of this file is important.

Deprecations do not count as incompatible, assuming that code using the

deprecated calls continues to see their documented behavior. But do

specify deprecation="yes" in <compatibility>.

This file is not a replacement for Javadoc: it is intended to list changes,

not describe the complete current behavior, for which ordinary documentation

is the proper place.

-->

<apichanges>

  <!-- First, a list of API names you may use: -->

  <apidefs>

    <!-- org.netbeans.api.looks -->

    <apidef name="api">Looks API</apidef>

    <!-- org.netbeans.spi.looks -->

    <apidef name="spi">Looks SPI</apidef>

  </apidefs>

<!-- ACTUAL CHANGES BEGIN HERE: -->

  <changes>

<!--  

  <change id="ErrorManager.getDefault">

      <api name="util"/>

      <summary>Added accessibility method ErrorManager.getDefault () that always returns non-null values</summary>

      <version major="2" minor="1"/>

      <date day="17" month="1" year="2002"/>

      <author login="jtulach"/>

      <compatibility addition="yes" modification="yes" deprecation="yes"/>

      <description>

        <p>

          This method allows independent libraries (nodes, filesystems, utilities) to use the ErrorManager without 

          testing if it is really present. Just call <code>ErrorManager.getDefault ()</code> and you can be sure 

          that a valid instance will be returned.

        </p>

        <p>

          Also <code>TopManager.getErrorManager</code> is no longer useful (<a

          href="#ErrorManager.getDefault">see change</a>) and is now deprecated.

          It is also not abstract as it just delegates.

          <code>notifyException</code> is similarly deprecated.

        </p>

      </description>

      <class package="org.openide" name="ErrorManager"/>

      <issue number="16854"/>

  </change>

-->  

  <change id="Look.getAttachedData">

    <api name="api"/>

    <summary>Look.getAttachedData added as a convenience method for accessing data attached to a 

        <code>NodeSubstitute</code>.

    </summary>

    <version major="0" minor="2"/>

    <author login="sdedic"/>

    <compatibility addition="yes"/>

    <description>

        This method is introduced as a counterpart for <code>Look.createAttachedData</code>, 

        it allows a convenient access to the <code>Object</code> returned from that method.

        <code>Look</code> subclasses are now advised to use this method to obtain data

        returned during initialization from <code>createAttachedData</code>

    </description>

    <class package="org.netbeans.api.looks" name="Look"/>

  </change>

  <change id="Look.createAttachedData">

    <api name="api"/>

    <summary>Look.createAttachedData added as a convenience method for attaching data to a

        <code>NodeSubstitute</code>

    </summary>

    <version major="0" minor="2"/>

    <author login="sdedic"/>

    <compatibility addition="yes"/>

    <description>

        The method allows to attach custom data to a <code>NodeSubstitute</code>.

        It should be overriden rather than <code>Look.attachTo</code>, which is

        declared <code>final</code> in some SPI classes.

        Subclasses are advised to override this method to return data to be attachedÿ

        to the <code>NodeSubstitute</code>. They may retrieve the data later using

        <code>getAttachedData</code>.

    </description>

    <class package="org.netbeans.api.looks" name="Look"/>

  </change>

  <change id="Look.attachTo">

    <api name="api"/>

    <summary>Look.attachTo delegates to <code>createAttachedData</code> in the

        default implementation.</summary>

    <version major="0" minor="2"/>

    <author login="sdedic"/>

    <compatibility modification="yes"/>

    <description>

        For most subclasses, it is now advised to override <code>createAttachedData</code>

        rather than <code>attachTo</code>. This method was changed to delegate to

        the <code>createAttachedData</code> for convenience.

    </description>

    <class package="org.netbeans.api.looks" name="Look"/>

  </change>

  <change id="Look.NodeSubstitute.getAttachedData">

    <api name="api"/>

    <summary><code>NodeSubstitute.getAttachedData</code> was made package private

    </summary>

    <version major="0" minor="2"/>

    <author login="sdedic"/>

    <compatibility modification="yes" source="incompatible" binary="incompatible"/>

    <description>

        The method was hidden (= package private). Clients are advised to use

        <code>Look.getAttachedData</code> instead.

    </description>

    <class package="org.netbeans.api.looks" name="Look"/>

  </change>

  <change id="NamespaceLook.namesFor">

    <api name="spi"/>

    <summary>NamespaceLook.namesFor has now default implementation</summary>

    <version major="0" minor="2"/>

    <author login="sdedic"/>

    <compatibility modification="yes"/>

    <description>

        A convenient implementation was added, which enumerates object's types

        from the runtime type information. This may serve as a basic extensibility

        point for Looks.

    </description>

    <class package="org.netbeans.spi" name="NamespaceLook"/>

  </change>

  <change id="ProxyLook.ATTACH_TO">

    <api name="spi"/>

    <summary>ProxyLook.ATTACH_TO constant was removed</summary>

    <version major="0" minor="2"/>

    <author login="sdedic"/>

    <compatibility deletion="yes" binary="compatible" source="incompatible"/>

    <description>

        ProxyLooks are no longer required nor called to return delegates to

        be attached to <code>NodeSubstitute</code>s from their <code>delegateTo</code>

        method. This is achieved by another less restrictive means.

    </description>

    <class package="org.netbeans.spi" name="ProxyLook"/>

  </change>

  <change id="ProxyLook.delegateTo">

    <api name="spi"/>

    <summary>ProxyLook.delegateTo can introduce new delegate Looks</summary>

    <version major="0" minor="2"/>

    <author login="sdedic"/>

    <compatibility deletion="yes" binary="compatible" source="incompatible"/>

    <description>

        Subclass may introduce new delegates in the returned array, even if

        the delegates for the particular operation were already asked for. 

        Subclasses are advised to maintain the position of returned delegates,

        as ProxyLook uses that property to improve CPU performance.

    </description>

    <class package="org.netbeans.spi" name="ProxyLook"/>

  </change>

  <!-- Now the surrounding HTML text and document structure: -->

  </changes>

  <htmlcontents>

<!--

                            NO NO NO NO NO!

         ==============>    DO NOT EDIT ME!  <======================

          AUTOMATICALLY GENERATED FROM APICHANGES.XML, DO NOT EDIT

                SEE openidex/looks/api/doc/changes/apichanges.xml

-->

    <head>

      <title>Looks API Changes by Date</title>

      <link rel="stylesheet" href="http://www.netbeans.org/netbeans.css" type="text/css"/>

      <meta name="CATEGORY" content="OtherDevelopmentDoc"/>

      <meta name="DESCRIPTION" content="A cross-indexed list of all changes made to the Looks API."/>

    </head>

    <body>

<h1>Introduction</h1>

<p>This document lists changes made to the <a href="http://openidex.netbeans.org/proposals/looks/">Looks

API</a>. Please ask on the <code>nbdev@netbeans.org</code> mailing list

if you have any questions about the details of a

change, or are wondering how to convert existing code to be compatible.</p>

<h2>What do the Dates Mean?</h2>

<p>The supplied dates indicate when the API change was made, on the CVS

trunk. From this you can generally tell whether the change should be

present in a given build or not; for trunk builds, simply whether it

was made before or after the change; for builds on a stabilization

branch, whether the branch was made before or after the given date. In

some cases corresponding API changes have been made both in the trunk

and in an in-progress stabilization branch, if they were needed for a

bug fix; this ought to be marked in this list.</p>

<ul>

<li>The <code>release33</code> branch was made on Nov 23 '01 for use in

the NetBeans 3.3.1 release, and later for development of Forte for Java (codename Orion).</li>

</ul>

<!-- The actual lists of changes, as summaries and details: -->

      <hr/><h1><a name="list-all-apis">Index of APIs</a></h1>

      <changelist style="list-all-apis"/>

      <h1><a name="incompat-by-date">Incompatible changes by date</a></h1>

      <p>Fuller descriptions of all changes can be found below (follow links).</p>

      <p>Not all deprecations are listed here, assuming that the deprecated

        APIs continue to essentially work. For a full deprecation list, please

        consult the

        Javadoc.</p>

      <changelist style="incompat-by-date"/>

      <h1><a name="all-by-date">All changes by date</a></h1>

      <changelist style="all-by-date"/>

      <h1><a name="all-by-version">Changes by version</a></h1>

      <p>

        These API specification versions may be used to indicate that a module

        requires a certain API feature in order to function. For example, if you

        see here a feature you need which is labelled <samp>1.2</samp>, your

        manifest should contain in its main attributes the line:

      </p>

      <pre>OpenIDE-Module-Module-Dependencies: org.netbeans.modules.looks<!--XXX /1 ?! --> &gt; 1.2</pre>

      <changelist style="all-by-version"/>

      <h1><a name="all-by-class">Changes by affected class</a></h1>

      <changelist style="all-by-class"/>

      <hr/><h1><a name="details-by-api">Details of all changes by API and date</a></h1>

      <changelist style="details-by-api"/>

    </body>

  </htmlcontents>

</apichanges>

/*

 *                 Sun Public License Notice

 * 

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 * 

 * The Original Code is NetBeans, Community Edition. The Initial

 * Developer of the Original Code is Sun Microsystems, Inc. Portions

 * Copyright 1997-2001 Sun Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.api.looks;

import org.openide.nodes.*;

import org.netbeans.spi.looks.FilterLook;

import org.openide.util.NbBundle;

/** A bean look to display an object as a JavaBean.

 * 

 * @author Jaroslav Tulach

 */

final class BeanLook extends FilterLook {

    /** Creates new NodeProxySupport */

    public BeanLook() {

        super (Look.NODES);

    }

    public String getName () {

        return "JavaBeans"; // NOI18N

    } 

    /** The human presentable name of the look.

     * @return human presentable name

     */

    public String getDisplayName() {

        return NbBundle.getMessage (BeanLook.class, "LAB_JavaBeans");

    }    

    /** Replaces each object with its bean node.

     */

    protected Object delegateObject (NodeSubstitute subst) {

        try {

            return new BeanNode (subst.getRepresentedObject ());

        } catch (java.beans.IntrospectionException ex) {

            return ex;

        }

    }

}

#                 Sun Public License Notice

# 

# The contents of this file are subject to the Sun Public License

# Version 1.0 (the "License"). You may not use this file except in

# compliance with the License. A copy of the License is available at

# http://www.sun.com/

# 

# The Original Code is NetBeans. The Initial Developer of the Original

# Code is Sun Microsystems, Inc. Portions Copyright 1997-2002 Sun

# Microsystems, Inc. All Rights Reserved.

#Name of the Look property sheet.

CTL_LookSheetSetName=Look

#Name of the Look property.

CTL_LookProperty=Look

#Short description of the look property

CTL_LookPropertyShortDescription=Sets the look on the node.

#Name of the Default look.

CTL_Default=Default

#Name of the SetLook Action

ACT_SetLook=View as

# Names of looks

LAB_NodeProxyLook=Nodes

LAB_Types=Default

LAB_JavaBeans=Java Beans

/*

 *                 Sun Public License Notice

 *

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 *

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2000 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.api.looks;

import java.awt.Image;

import java.awt.datatransfer.Transferable;

import java.io.IOException;

import javax.swing.Action;

import org.openide.nodes.*;

import org.openide.util.HelpCtx;

import org.openide.util.datatransfer.NewType;

import org.openide.util.datatransfer.PasteType;

import org.openide.util.Lookup;

import java.lang.ref.WeakReference;

import java.util.Enumeration;

import org.openide.util.enum.AlterEnumeration;

import org.openide.util.enum.FilterEnumeration;

import java.util.NoSuchElementException;

/** Base class for all looks. This class handles basic reading of properties

 * from XML description.

 * <P>

 * Notice the difference between the methods which take the parameter of

 * type NodeSubstitute and the methods which don't. The first methods are

 * those which implement the functionality of the look. The second are methods 

 * which represent properties of the Look itself.

 * <P>

 *

 * @author Petr Hrebejk

 */

public abstract class Look implements Node.Cookie, java.io.Serializable {

    /** Look that works with <link>Node</link>. If the represented object

     * is <code>Node</code> the look takes its name, actions, properties, etc.

     * Very useful for bridging to already written nodes.

     */

    public static final Look NODES = new NodeProxyLook ();

    /** Look that finds the correct look by the type of the 

     * represented object. It searches naming space of "Looks/Types/"

     * @see NamespaceLook

     */

    public static final Look DEFAULT = new TypesLook ();

    /** Look that presents an object as a JavaBean. Uses java.beans.Introspector

     * to get the properties and delegates to the object all other methods.

     */

    public static final Look BEANS = new BeanLook ();

    /** lock to synchronize access to substitute variable.

     */

    private static final String NLOCK = "NLock";

    /** reference to the NodeSubstitute link list. Lists all substitutes this

     * look is attached to.

     */

    private NLink substitutes;

    // Methods of look itself --------------------------------------------------

    /** Returns name of the look. This name should identify the look.

     * @return Name of the look.

     */

    public abstract String getName();

    /** The human presentable name of the look. 

     * @return human presentable name

     */

    public abstract String getDisplayName ();

    // General methods ---------------------------------------------------------

    /** 

     * Called on the current look when node is newly created or the look is

     * set on the Node. Overriding this 

     * method allows to register listners on represented objects and asociate

     * them with the node.

     * <p>

     * Implementors may not wait for any other threads at it may be potentially called

     * from LookNode's lock.

     * <P>

     * The look can return an instance of any object in order to store its 

     * own data with the substitute. The data can then be obtained by calling

     * <link>Look.NodeSubstitute.getAttachedData</link>. 

     * 

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the which was created.

     * @return the object that contains data of the look associated with the

     *      substitute or <code>null</code> if no such data are needed

     */ 

    protected Object attachTo( Look.NodeSubstitute substitute ) {

        return createAttachedData(substitute);

    }

    /**

     * This method is called during the process of attaching a Look to a 

     * <link>NodeSubstitute</link>. Subclasses can override this method to attach

     * custom data to the NodeSubstitute instance so they can retrieve it

     * later.<BR>

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the which was created.

     * @return the object that contains data of the look associated with the

     *      substitute or <code>null</code> if no such data are needed

     */

    protected Object createAttachedData(Look.NodeSubstitute subst) {

        return null;

    }

    /**

     * Retrieves the data, previously attached to the <link>NodeSubstitute</link>.

     * The method returns null, if this Look is no longer selected one for the 

     * <code>NodeSubstitute</code> or <link>createAttachedData</link> returned

     * null.

     * @see #createAttachedData

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node to operate on.

     * @return The instance previously returned from <link>createAttachedData</link>

     * or null if there was no data, or the Look is not selected on the <code>Node</code>

     */

    protected Object getAttachedData(Look.NodeSubstitute subst) {

        if (subst == null)

            return null;

        return subst.getAttachedData(this);

    }

    /** Creates lookup object with additional "cookies" for the LookNode using

     * the provided node substitute. The LookNode attaches calls this method just

     * once and attaches listener to the returned lookup so all changes in it

     * will result in PROP_COOKIE change in the LookNode.

     *

     *

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node to operate on.

     * @return the lookup to be used by the LookNode or null if no additional cookies are

     *      provided

     */

    public abstract Lookup createLookup (Look.NodeSubstitute substitute);

    /** A list of possible looks this look can be replaced with.

     * This list depends on the look itself and should contain looks 

     * a user might find meaningful to use instead of this one.

     *

     * @param substitute substitute to find modes for

     * @return the array of looks or null if the no switching is available

     */

    public abstract Look[] availableLooks ( Look.NodeSubstitute substitute );

    // Methods for STYLE -------------------------------------------------------

    /** Gets localized name of given Node. This name will be showed in the 

     * visual representation of the node. 

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node to operate on.

     * @return Localized name of the node. Implementation of {@link LookNode} 

     *         defaults this to the programmatic name of the node.

     */

    public abstract String getDisplayName( Look.NodeSubstitute substitute );

    /** Gets the progammatic name of given node. This name can be used for 

     * operations on node paths in the node hierarchy and thus shouldn't be

     * localized.

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node to operate on.

     * @return Programmatic name of the node. 

     */

    public abstract String getName( Look.NodeSubstitute substitute );

    /** This method is clalled when the user renames the node using inplace

     * editing in the view.

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the renamed node.

     * @param newName The new name set by the user.

     */

    public abstract void setName( Look.NodeSubstitute substitute, String newName );

    /** Gets short description of given node. The short description is usually

     * visualized as a tooltip, but may have another forms as well.

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node to operate on.

     * @return A localized short description associated with the node. 

     *         Implementation of {@link LookNode} defaults this to display name 

     *         of the node.

     */

    public abstract String getShortDescription( Look.NodeSubstitute substitute );

    /** Find an icon for this node (in the closed state).

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node to operate on.

     * @param type Constant from {@link java.beans.BeanInfo}

     * @return Icon to use to represent the node in the closed state. 

     *         Implementation of {@link LookNode} provides default icon for nodes.

     */

    public abstract Image getIcon( Look.NodeSubstitute substitute, int type );

    /** Find an icon for this node (in the open state).

     * This icon is used when the node may have children and is expanded.

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node to operate on.

     * @param type Constant from {@link java.beans.BeanInfo}

     * @return Icon to use to represent the node in the open state. 

     *        Implementation of {@link LookNode} defaults this to the closed

     *        state icon.

     */

    public abstract Image getOpenedIcon( Look.NodeSubstitute substitute, int type );

    /** Get context help associated with this node.

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node to operate on.

     * @return The context help object (could be <code>null</code> or 

     *         {@link HelpCtx#DEFAULT_HELP}) 

     */

    public abstract HelpCtx getHelpCtx( Look.NodeSubstitute substitute );

    // Methods for CHILDREN ----------------------------------------------------

    /** Gets objects which are children of object represented by the node in the

     * hierarchy represented by this Look.

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node to operate on.

     * @return Array of objects which should be represend as node children of 

     *         the node, can return <code>null</code> that is equivalant to empty array

     */

    public abstract Object[] getChildObjects( Look.NodeSubstitute substitute );

    // Methods for ACTIONS & NEW TYPES -----------------------------------------

    /** Get the new types that can be created in given node.

     * For example, a node representing a Java package will permit classes to 

     * be added.

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node to operate on.

     * @return Array of new type operations that are allowed,

     *     can return <code>null</code> that is equivalant to empty array

     */

    public abstract NewType[] getNewTypes( Look.NodeSubstitute substitute );

    /** Get the set of actions associated with the node.

     * This may be used e.g. in constructing a {@link #getContextMenu context menu}.

     * <P>

     * If the look returns null, the implementation {@ling LookNode} returns 

     * the actions in {@link NodeOp#getDefaultActions} obtained by the super call.

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node to operate on.

     * @return Array of the Actions applicable to the node or <CODE>null</CODE>

     *         if actions in {@link NodeOp#getDefaultActions} should be used.

     */

    public abstract Action[] getActions( Look.NodeSubstitute substitute );

    /** Get a special set of actions for situations when this node is displayed 

     * as a context.

     * @see org.openide.nodes.Node#getContextActions For more detailed description.

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the The node to operate on.

     * @return Actions for a context. In the LookNode implementation, 

     *        same as {@link #getActions}.

     * 

     */

    public abstract Action[] getContextActions( Look.NodeSubstitute substitute );

    /** Get the default action for this node.

     * This action can but need not be one from the list returned

     * from {@link #getActions}. If so, the popup menu returned from 

     * {@link #getContextMenu} is encouraged to highlight the action.

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node to operate on.

     * @return Default action, or <code>null</code> if there should be none.

     */

    public abstract Action getDefaultAction( Look.NodeSubstitute substitute );

    // Methods for PROPERTIES AND CUSTOMIZER -----------------------------------

    /** Get the list of property sets for given node. E.g. typically there 

     * may be one for normal Bean properties, one for expert

     * properties, and one for hidden properties.

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the The node to operate on.

     * @return Property sets for the node, can return <code>null</code> that is equivalant to empty array

     */

    public abstract Node.PropertySet[] getPropertySets( Look.NodeSubstitute substitute );

    /** Is the customizer for represented object available? If so, the method

     * getCustomizer should return non-null value.

     *

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node to operate on.

     * @return true if the customizer is available, false otherwise

     */

    public abstract boolean hasCustomizer( Look.NodeSubstitute substitute );

    /** Get the customizer for represented object if available.

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node to operate on.

     * @return The component, or <CODE>null</CODE> if there is no customizer. 

     */

    public abstract java.awt.Component getCustomizer( Look.NodeSubstitute substitute );

    // public boolean hasCustomizer (); Not necesary

    // Methods for CLIPBOARD OPERATIONS ----------------------------------------

    /** Test whether this node can be renamed.

     * If true, {@link #setName} will be called when the user changes the name

     * of the node.

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node to operate on.

     * @return <code>true</code> if the node can be renamed.

     */

    public abstract boolean canRename( Look.NodeSubstitute substitute );

    /** Test whether this node can be deleted.

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node to operate on.

     * @return <CODE>True</CODE> if can be deleted.

     */

    public abstract boolean canDestroy( Look.NodeSubstitute substitute );

    /** Test whether this node permits copying.

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node to operate on.

     * @return <code>True</code> if so.

     */

    public abstract boolean canCopy( Look.NodeSubstitute substitute );

    /** Test whether this node permits cutting.

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node to operate on.

     * @return <code>True</code> if so.

     */

    public abstract boolean canCut( Look.NodeSubstitute substitute );

    /** Determine which paste operations are allowed when a given 

     * transferable is in the clipboard. For example, a node representing a 

     * Java package will permit classes to be pasted into it.

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node to operate on.

     * @param t The transferable in the clipboard.

     * @return Array of operations that are allowed, can return <code>null</code> that is equivalant to empty array

     */

    public abstract PasteType[] getPasteTypes( Look.NodeSubstitute substitute, Transferable t);

    /** Determine if there is a paste operation that can be performed

     * on provided transferable. Used by drag'n'drop code to check

     * whether the drop is possible.

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node to operate on.

     * @param t The transferable.

     * @param action The drag'n'drop action to do DnDConstants.ACTION_MOVE, 

     *        ACTION_COPY, ACTION_LINK.

     * @param index Index between children the drop occured at or -1 if not specified.

     * @return <CODE>Null</CODE> if the transferable cannot be accepted or the paste type

     *         to execute when the drop occures.

     */

    public abstract PasteType getDropType( Look.NodeSubstitute substitute, Transferable t, int action, int index);

    /** Called when a node is to be copied to the clipboard.

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node Copy was invoked on.

     * @return The transferable object representing the content of the clipboard.

     * @throws IOException When the copy cannot be performed.

     */

    public abstract Transferable clipboardCopy( Look.NodeSubstitute substitute ) throws IOException;

    /** Called when the node is to be cut to the clipboard.

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node to be cutted.

     * @return The transferable object representing the content of the clipboard.

     * @throws IOException When the copy cannot be performed.

     */

    public abstract Transferable clipboardCut( Look.NodeSubstitute substitute ) throws IOException;

    /** Called when a drag is started with this node.

     * The node can attach a transfer listener to ExTransferable and

     * will be then notified about progress of the drag (accept/reject).

     * @param substitute The <CODE>Look.NodeSubstitute</CODE> of the node which was dragged.

     * @return Transferable to represent this node during a drag.

     * @throws IOException If a drag cannot be started.

     */

    public abstract Transferable drag( Look.NodeSubstitute substitute ) throws IOException;

    /** Called when node was destroyed.

     * @param substitute Look.NodeSubstitute of the destroyed ndoe.

     */

    public abstract void destroy( Look.NodeSubstitute substitute ) throws IOException;

    /** List of all NodeSubstitutes that use this look. Is useful when the look

     * changes some of its properties and needs to update all substitutes.

     *

     * @return enumeration of NodeSubstitute

     */

    protected final Enumeration nodeSubstitutes () {

        Enumeration en = new Enumeration () {

            private NLink current = substitutes;

            public boolean hasMoreElements () {

                return current != null;

            }

            public Object nextElement () {

                synchronized (NLOCK) {

                    if (current == null) {

                        throw new NoSuchElementException ();

                    }

                    Object o = current;

                    current = current.next;

                    return o;

                }

            }

        };

        AlterEnumeration alt = new AlterEnumeration (en) {

            private NLink previous;

            public Object alter (Object o) {

                NLink n = (NLink)o;

                if (n == null) {

                    return null;

                }

                synchronized (NLOCK) {

                    NodeSubstitute subst = (NodeSubstitute)n.get ();

                    if (subst == null || subst.getLook () != Look.this) {

                        // need to exclude this object from the list

                        if (previous == null) {

                            // we need to change looks first substitute

                            Look.this.substitutes = n.next;

                        } else {

                            // need to skip this one from the previous 

                            previous.next = n.next;

                        }

                        // anyway we will not accept the object

                        return null;

                    }

                    return subst;

                }

            }

        };

        // exclude nulls

        return new FilterEnumeration (alt);

    }

    // Innerclasses ------------------------------------------------------------

    /** Class passed to the Look methods as parameter. Each LookNode contains 

     * exactly one instance of this class. Metods of the class allow access

     * to the properties and methods od the node needed for the Look.

     * @version 0.2

     */

    public static abstract class NodeSubstitute {

        /** the look this substitute is attached to or null */

        private Look look;

        /** data of the look attached to this substitute */

        private Object data;

        /** Attaches the substitute to a provided look. Does nothing if

         * the previously attached look is the same as the provided one.

         * If it is different, the substitute is detached from a look and

         * attached to the new one.

         *

         * <P>

         * Method attachTo is called on the look to let it know about this

         * substitute and to let it store additional data <link>getAttachedData</link>

         * with this NodeSubstitute.

         *

         * @param look look to attach to or null if we should detach

         */

        protected final void attachTo (Look look) {

            synchronized (NLOCK) {

                if (look == this.look) {

                    // ok no change

                    return;

                }

                this.look = look;

                if (look == null) {

                    // clear all values

                    data = null;

                    return;

                }

                NLink l = look.substitutes;

                look.substitutes = new NLink (this, l);

                this.data = look.attachTo (this);

            }

        }

        /** Access to the look this substitute is attached to.

         * @return the look we are attached to or null if not attached at all

         */

        public final Look getLook () {

            return look;

        }

        /** Fire a property change event on the associated node.

         * @param name name of changed property (from {@link #getPropertySets})

         * @param o old value

         * @param n new value

         */

        abstract public void firePropertyChange( String name, Object o, Object n );

        /** Fires the Event notificationg about name change.

         */

        abstract public void fireNameChange( String o, String n ); 

        /** Fires the Event notificationg about display name change.

         */

        abstract public void fireDisplayNameChange( String o, String n );

        /** Fires the Event notificationg about short description change.

         */

        abstract public void fireShortDescriptionChange(String o, String n); 

        /** Fire a change event for {@link org.openide.nodes.Node#PROP_ICON} on

         * associated node.

         */

        abstract public void fireIconChange();

        /** Fire a change event for {@link org.openide.nodes.Node#PROP_OPENED_ICON} on

         * associated node.

         */

        abstract public void fireOpenedIconChange(); 

        /** Fires a (Bean) property change event (for 

         * {@link org.openide.node.Node#PROP_PROPERTY_SETS}).

         * @param o the old set

         * @param n the new set

         */

        abstract public void firePropertySetsChange( Node.PropertySet[] o, Node.PropertySet[] n );

        /** To all node listeners fire node destroyed notification.

         */

        abstract public void fireNodeDestroyed();

        /** Tells the node that the children have to be refreshed.

         */

        abstract public void refreshChildren(); 

        //

        // Informations for the Look

        //

        /** Returns the object represented by the node

         * @return Object represented by the node this interior belongs to.

         */

        public abstract Object getRepresentedObject(); 

        /** Returns the data associated with the substitute by the Look

         * Made package-private from version 0.2. Use <link>Look.getAttachedData</link>

         * instead.

         * @see Look.createAttachedData

         * @return the object provided by <code>Look.createAttachedData</code>

         */

        final Object getAttachedData(Look look) {

            synchronized (NLOCK) {

                if (getLook() != look)

                    return null;

            }

            return data;

        }

    } // end of NodeSubstitute

    /** NodeSubstitute linked list with weak references.

     */

    private static final class NLink extends WeakReference {

        /** link to next NLink or null */

        public NLink next;

        public NLink (NodeSubstitute substitute, NLink next) {

            super (substitute);

            this.next = next;

        }

    } // end of NLink

}

/*

 *                 Sun Public License Notice

 * 

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 * 

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2000 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.api.looks;

import java.util.*;

import org.openide.nodes.*;

/** <B>WARNING</B> - This API is not finished and is subject to change<BR> 

 * Please don't use this API for other purposes than testing.

 * <P>

 * Temporary implementation of Children of a LookNode. The class contains

 * only code wich is necessary for testing looks and may be extended later.

 *

 * @author Petr Hrebejk

 */

final class LookChildren extends Children.Keys {

    /** Use this constant for returning empty KeySets. */

    private static final Object[] NO_KEYS = {};

    /** @param brutal needs clean */

    void refreshChildren( boolean brutal ) {            

        if (brutal) {

            setKeys (Collections.EMPTY_LIST);

        }

        final Object[] keys = getKeys();

        MUTEX.postWriteRequest(new Runnable() {

            public void run() {

                setKeys( keys );

            }

        });

    }

    protected void addNotify() {

        setKeys( getKeys() );

    }

    protected void removeNotify() {

        setKeys( Collections.EMPTY_LIST );

    }

    protected Node[] createNodes( Object key ) {

        if (key == null) return new Node[0];

        Node n = getNode ();

        if (! (n instanceof LookNode)) {

            Look l = (Look)n.getCookie (Look.class);

            if (l == null) {

                l = Look.DEFAULT;

            }

            return new Node[] { new LookNode (key, l) };

        }

        LookNode ln = (LookNode)n;

        LookNode node = new LookNode (key, ln.getBaseLook ());

        // is not there a better look?

        Look l = ln.findLookForChild (node);

        if (l != null && node.getLook () != l) {

            node.setLook (l);

        }

        return new Node[] { node };

    }

    // Private methods ---------------------------------------------------------

    private Object[] getKeys() {

        Object[] keys = ((LookNode)getNode ()).getChildObjects ();

        if ( keys == null ) {

            return NO_KEYS;

        }

        else {

            return keys;

        }

    }

}

/*

 *                 Sun Public License Notice

 * 

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 * 

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2000 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.api.looks;

import java.beans.*;

import java.awt.Image;

import java.awt.datatransfer.Transferable;

import java.io.IOException;

import java.util.Map;

import javax.swing.Action;

import org.openide.nodes.*;

import org.openide.util.HelpCtx;

import org.openide.util.Utilities;

import org.openide.util.actions.SystemAction;

import org.openide.util.datatransfer.NewType;

import org.openide.util.datatransfer.PasteType;

import org.openide.util.Lookup;

import org.openide.util.LookupEvent;

import org.openide.util.LookupListener;

import org.openide.util.Mutex;

import org.openide.util.MutexException;

import java.util.HashMap;

import java.util.Iterator;

import org.netbeans.spi.looks.ProxyLook;

/** 

 * Node that represents an object using Looks.

 *

 * @author Petr Hrebejk

 */

public final class LookNode extends Node implements Node.Cookie {

    /** it is our private lock changes of delegates for given nodes */

    private final Mutex MUTEX = new Mutex ();

    /** Use this constant for returning no Actions. */

    private static final SystemAction[] NO_SYSTEM_ACTIONS = {};

    /** Use this constant for returning empty NewTypes. */

    private static final NewType[] NO_NEW_TYPES = {};

    /** Use this constant for returning empty PasteTypes. */

    private static final PasteType[] NO_PASTE_TYPES = {};

    /** Use this constant for returning empty PropertySets. */

    private static final Node.PropertySet[] NO_PROPERTY_SETS = {};

    /** Name of the default icon 16x16 */

    private static final String DEFAULT_ICON_16_NAME = 

        "org/netbeans/modules/looks/resources/defaultNode.gif"; // NOI18N

    /** Name of the default icon 32x32 */

    private static final String DEFAULT_ICON_32_NAME = 

        "org/netbeans/modules/looks/resources/defaultNode32.gif"; //NOI18N

    /** Maximum of looks that is kept in memory. This should not be

     * infihite, but it also should be adjusted to the user experience -

     * how many selections are important to the user!?

     */

    private static final int MAX_MEMORY = 30;

    /** the base look associated with this node */

    private Look base;

    /** the actual look associated with this node */

    private Look look;

    /** Object represented (delegeted) by interior */

    private SubstituteImpl substitute;

    /** represented object */

    private Object representedObject;

    /** mapping from names of nodes to names of looks. Each node can have

     * such mapping - it will influence the persistence of selected objects

     *

     * Map with <String, String>

     */

    private Map map;

    /** Creates new LookNode with <link>Look.DEFAULT</link> as associated look.

     *

     * @param representedObject The object which the node will represent.

     */

    public LookNode( Object representedObject ) {

        this (representedObject, Look.DEFAULT);

    }

    /** Creates new LookNode.

     * @param representedObject The object which the node will represent.

     * @param look explicit look that will be set

     */

    public LookNode( Object representedObject, Look look) {

        this (representedObject, look, look);

    }

    /** Creates new LookNode.

     * @param representedObject The object which the node will represent.

     * @param base the base look to use

     * @param look explicit look that will be set 

     */

    /*public*/ LookNode (Object representedObject, Look base, Look look) {

        super (new LookChildren ());

        this.base = base;

        this.look = look;

        this.representedObject = representedObject;

        // Create the interior

        substitute = new SubstituteImpl(this, look);

    }

    // Additional methods for LookNode -----------------------------------------

    /** Used to get Substitute of this LookNode

     * @return NodeSubstitute

     */

    final SubstituteImpl getSubstitute(){

        return (SubstituteImpl) MUTEX.readAccess (new Mutex.Action () {

            public Object run () {

                return substitute;

            }

        });

    }

    final Object[] getChildObjects() {

        return (Object []) MUTEX.readAccess (new Operation (ProxyLook.GET_CHILD_OBJECTS));

    }

    /** Returns represented object which this LookNode represents.

     * @return The object represented by this node.

     */

    public Object getRepresentedObject() {

        return representedObject;

    }

    /** Sets the actual look for this node. After changing the Look several property

     * changes are fired:

     * <CODE>PROP_COOKIE, PROP_NAME, PROP_NAME, PROP_DISPLAY_NAME, PROP_ICON,

     * PROP_OPENED_ICON</CODE> and children are refresehed.

     * @look New look of the node.

     */

    public void setLook( final Look look ) {        

        String name = look.getName ();

        MUTEX.writeAccess (new Runnable () {

            public void run () {

                LookNode.this.look = look; // new current look

                substitute.clean (); // not used anymore

                SubstituteImpl newsubst = new SubstituteImpl (LookNode.this, look);

                substitute = newsubst;

                // commented out as hotfix of #24424

                //recordLook (this, base, name);

            }

        });

        // fire possible change notifications

        fireCookieChange();

        refreshChildren(true);

        fireNameChange( null, null );

        fireDisplayNameChange( null, null );

        fireIconChange();

        fireOpenedIconChange();

    }

    /** Refreshes children on the node */

    void refreshChildren(boolean brutal) {

        ((LookChildren)getChildren()).refreshChildren(brutal);

    }

    // methods to track the state of the tree

    /** Stores the name of the selected look.

     * @param node node to store the name for

     * @param nameLook look that should be used to create node's names

     * @param look the name of the look

     */

    private static void recordLook (LookNode node, Look nameLook, String look) {

        StringBuffer buf = new StringBuffer (512);

        for (;;) {

            Node parent = node.getParentNode();

            if (parent == null) break;

            parent = (LookNode)parent.getCookie (LookNode.class);

            if (parent == null) break;

            node = (LookNode)parent;

            buf.insert (0, nameLook.getName (node.getSubstitute ()));

        }

        synchronized (node) {

            if (node.map == null) {

                node.map = new HashMap ();

            }

            if (node.map.size () > MAX_MEMORY) {

                int rand = (int)(Math.random() * MAX_MEMORY);

                Iterator it = node.map.entrySet ().iterator();

                while (rand-- > 0) {

                    it.next ();

                }

                it.remove();

            }

            node.map.put (buf.toString ().intern(), look);

        }

    }

    /** Finds proposed look in storage (if any) for this node.

     * @return name of suggested look for our current state or null

     */

    Look findLookForChild (LookNode child) {

        String name = child.getName ();

        LookNode node = this;

        StringBuffer buf = new StringBuffer (512);

        buf.append (name);

        for (;;) {

            if (node == null) {

                return null;

            }

            if (node.map != null) {

                name = (String)node.map.get (buf.toString ());

                if (name != null) {

                    // found a name now find the look

                    return child.lookByName (child.getBaseLook(), name);

                }

            }

            buf.insert (0, node.getName ());

            Node p = node.getParentNode ();

            if (p == null) {

                break;

            }

            node = (LookNode)p.getCookie(LookNode.class);

            if (node == null) {

                return null;

            }

        }

        return null;

    }

    /** Finds a look by name.

     * @param look the look to search in

     * @param name name to find

     * @return the look or null

     */

    private final Look lookByName (Look base, String name) {

        if (name.equals (base.getName ())) {

            return base;

        }

        Look[] arr = base.availableLooks (getSubstitute ());

        for (int i = 0; i < arr.length; i++) {

            base = lookByName (arr[i], name);

            if (base != null) {

                return base;

            }

        }

        return null;

    }

    // General methods ---------------------------------------------------------

    /** 

     * Gets the actual look set on this node. 

     * @return Look set on this Node

     * 

     */

    public Look getLook() {

        return look;

    }

    /** Getter for the base look.

     */

    final Look getBaseLook () {

        return base;

    }

    /** Gets Cookie of given type. The set of Cookies is determined by the

     * Look. Look of the node can allways be asked using <CODE>getCookie( 

     * Look.class )</CODE> and the LookNode self can be asked by 

     * <CODE>getCookie( LookNode.class )</CODE>.

     * @param type the representation class of the cookie

     * @return a cookie assignable to that class, or <code>null</code> 

     * the Look does not provide such cookie.

     */

    public Node.Cookie getCookie (Class type) {

        if ( type == Look.class ) {

            // Look is available in cookies

            return getLook();

        } else if ( type == LookNode.class ) {

            return this;

        } else {            

            // Ask the Looks for additional cookies

            Object c = getSubstitute ().getCookie (type);

            return c instanceof Node.Cookie ? (Node.Cookie)c : null;

        }

    }

    /** Determines Handle by querying the Look.

     * @return the handle, or <code>null</code> if this node is not persistable

     */

    public Node.Handle getHandle() {

        if (map != null) {

            return new H (map, getRepresentedObject ());

        } else {

            return DefaultHandle.createHandle (this);

        }

    }

    /** 

     * Returns a node representing the same object as the original node. Looks

     * passed in constructor and in setLook method are copied as well.

     *

     * @return LookNode representing the same object.

     */

    public Node cloneNode () {

        return new LookNode( getRepresentedObject(), base, look); 

    }

    // Methods for STYLE -------------------------------------------------------

    /** Determines displayName by querying the Look.

     * @return DisplayName provided by the Look or result 

     * of {@link #getName()}.

     */

    public String getDisplayName() {

        return (String) MUTEX.readAccess (new Mutex.Action () {

            public Object run () {

                String  displayName = getLook().getDisplayName( substitute );

                if ( displayName == null ) {

                    return getName();

                } else {

                    return displayName;

                }

            }

        });

    }

    /** Empty method, setting <CODE>displayName</CODE> on the 

     * <CODE>LookNode</CODE> has no efect. The <CODE>displayName</CODE> should

     * be determined by associated <CODE>Look</CODE>.

     * @param name Parameter is ignored. 

     */

    public void setDisplayName( String name ) {

    }

    /** Determines name by querying the Look.

     * @return Name provided by the Look or <CODE>null</CODE>.

     */

    public String getName() {

        return (String) MUTEX.readAccess (new Operation (ProxyLook.GET_NAME));

    }

    /** Invoking this method on LookNode invokes method {@link Look#setName( 

     * Look.NodeSubstitute, String )}. Look is responsible for handling the call.

     */

    public void setName( String s ) {

        MUTEX.readAccess (new Operation (ProxyLook.SET_NAME, s));

    }

    /** Empty method, setting <CODE>shortDescription</CODE> on the 

     * <CODE>LookNode</CODE> has no efect. The <CODE>shortDescription</CODE> 

     * should be determined by associated <CODE>Look</CODE>.

     * @param shortDescription Parameter is ignored.

     */

    public void setShortDescription( String shortDescription ) {

    }

    /** Determines shortDescription by querying the Look.

     * @return Name provided by the Look or result of {@link getDisplayName()}.

     */

    public String getShortDescription() {

        return (String) MUTEX.readAccess (new Mutex.Action () {

            public Object run () {

                String shortDescription = getLook().getShortDescription( substitute );

                if ( shortDescription == null ) {

                    return getDisplayName();

                } else {

                    return shortDescription;

                }

            }

        });

    }

    /** Determines icon for closed state by querying the Look.

     * @return Icon provided by the Look 

     */

    public Image getIcon( int type ) {

        Image icon = (Image) MUTEX.readAccess (new Operation (ProxyLook.GET_ICON, new Integer (type)));

        if ( icon == null ) {

            if ( type == BeanInfo.ICON_COLOR_32x32 || type == BeanInfo.ICON_MONO_32x32 ) {

                return Utilities.loadImage( DEFAULT_ICON_32_NAME );

            }

            return Utilities.loadImage( DEFAULT_ICON_16_NAME );

        }

        else {

            return icon;

        }

    }

    /** Determines icon for opened state by querying the Look.

     * @return Icon provided by the Look or the result of

     * {@link getIcon()}.

     */

    public Image getOpenedIcon( final int type ) {

        return (Image) MUTEX.readAccess (new Mutex.Action () {

            public Object run () {

                Image icon = getLook().getOpenedIcon( substitute, type );

                if ( icon == null ) {

                    return getIcon( type );

                } else {

                    return icon;

                }

            }

        });

    }

    /** Determines HelpCtx for opened state by querying the Look.

     * @return HelpCtx provided by the Look.

     */

    public HelpCtx getHelpCtx () {

        return (HelpCtx) MUTEX.readAccess (new Operation (ProxyLook.GET_HELP_CTX));

    }

    // Methods for ACTIONS & NEW TYPES -----------------------------------------

    /** Determines NewTypes for opened state by querying the Look.

     * @return NewTypes provided by the Look.

     */

    public NewType[] getNewTypes() {

        NewType arr [] = (NewType []) MUTEX.readAccess (new Operation (ProxyLook.GET_NEW_TYPES));

        return arr == null ? NO_NEW_TYPES : arr;

    }

    public SystemAction[] getActions() {

        return toSA (getCommands ());

    }

    /** Implementation of the getActions command with the expected signature

     * of a method that will be used in future

     *

     * @return the actions supported by this node

     */

    private Action[] getCommands () {

        Action[] systemActions;

        Action[] mergedActions;

        systemActions = (Action[]) MUTEX.readAccess (new Operation (ProxyLook.GET_ACTIONS));

        if (systemActions == null) {

            systemActions = super.getActions();

        }

        int actlen = systemActions.length;

        mergedActions = new Action[actlen + 2];

        System.arraycopy( systemActions, 0, mergedActions, 0, actlen );

        Action sla = LookProperties.getSetLookAction ();

        System.arraycopy( new Action[]{

         null,

         sla

        }, 0, mergedActions, actlen, 2 );

        return mergedActions;

    }

    public SystemAction [] getContextActions() {

        Action[] arr = (Action[]) MUTEX.readAccess (new Operation (ProxyLook.GET_CONTEXT_ACTIONS));

        return arr != null ? toSA (arr) : NO_SYSTEM_ACTIONS;

    }

    public SystemAction getDefaultAction() {

        Action a = (Action) MUTEX.readAccess (new Operation (ProxyLook.GET_DEFAULT_ACTION));

        return a instanceof SystemAction ? (SystemAction)a : null;

    }

    /** A convertor that takes array of Actions and return array of SystemActions

     * @param arr array of Action

     * @return array of SystemActions

     */

    private static SystemAction[] toSA (Action[] arr) {

        SystemAction[] sa = new SystemAction[arr.length];

        for (int i = 0; i < arr.length; i++) {

            if (arr[i] instanceof SystemAction) {

                sa[i] = (SystemAction)arr[i];

            }

        }

        return sa;

    }

    // Methods for PROPERTIES AND CUSTOMIZER -----------------------------------

    public Node.PropertySet[] getPropertySets() {

        Node.PropertySet[] sets = (Node.PropertySet[]) MUTEX.readAccess (new Operation (ProxyLook.GET_PROPERTY_SETS));

        if (sets == null) {

            sets = NO_PROPERTY_SETS;

        }

        Node.PropertySet[] all = new Node.PropertySet[ sets.length + 1 ];

        System.arraycopy( sets, 0, all, 0, sets.length );

        Sheet.Set set = LookProperties.getLookPropertySet( this );

		/*

        set.setName( LookProperties.LOOK_SHEET_SET_NAME );

        set.setDisplayName( LookProperties.LOOK_SHEET_SET_NAME );

        set.put( new LookProperties.LookProperty( this ) ); 

        */

        all[ all.length - 1] = set;

        return all;

    }

    public java.awt.Component getCustomizer() {

        return (java.awt.Component) MUTEX.readAccess (new Operation (ProxyLook.GET_CUSTOMIZER));

    }

    public boolean hasCustomizer () {

        return ((Boolean) MUTEX.readAccess (new Operation (ProxyLook.HAS_CUSTOMIZER))).booleanValue();

    }

    // Methods for CLIPBOARD OPERATIONS ----------------------------------------

    public boolean canRename() {

        return ((Boolean) MUTEX.readAccess (new Operation (ProxyLook.CAN_RENAME))).booleanValue();

    }

    public boolean canDestroy() {

        return ((Boolean) MUTEX.readAccess (new Operation (ProxyLook.CAN_DESTROY))).booleanValue();

    }

    public boolean canCopy() {

        return ((Boolean) MUTEX.readAccess (new Operation (ProxyLook.CAN_COPY))).booleanValue();

    }

    public boolean canCut() {

        return ((Boolean) MUTEX.readAccess (new Operation (ProxyLook.CAN_CUT))).booleanValue();

    }

    public PasteType[] getPasteTypes( Transferable t) {

        PasteType[] arr = (PasteType[]) MUTEX.readAccess (new Operation (ProxyLook.GET_PASTE_TYPES, t));

        return arr != null ? arr : NO_PASTE_TYPES;

    }

    public PasteType getDropType( Transferable t, int action, int index) {

        return (PasteType) MUTEX.readAccess (new Operation (

            ProxyLook.GET_DROP_TYPE, t, new Integer (action), new Integer (index)));

    }

    public Transferable clipboardCopy() throws IOException {

        try {

            return (Transferable) MUTEX.readAccess (new OperationException (ProxyLook.CLIPBOARD_COPY));

        } catch (MutexException e) {

            throw (IOException) e.getException ();

        }

    }

    public Transferable clipboardCut() throws IOException {

        try {

            return (Transferable) MUTEX.readAccess (new OperationException (ProxyLook.CLIPBOARD_CUT));

        } catch (MutexException e) {

            throw (IOException) e.getException ();

        }

    }

    public Transferable drag() throws IOException {

        try {

            return (Transferable) MUTEX.readAccess (new OperationException (ProxyLook.DRAG));

        } catch (MutexException e) {

            throw (IOException) e.getException ();

        }

    }

    public void destroy () throws IOException {

        try {

            MUTEX.readAccess (new OperationException (ProxyLook.DESTROY));

        } catch (MutexException e) {

            throw (IOException) e.getException ();

        }

        super.destroy();

    }

/*    

    boolean hasLookNodeParent() {

        Node parent = getParentNode();

        return parent != null && parent instanceof LookNode;

    }

*/    

    // Operation innerclass -----------------------------------------------------

    private final class Operation implements Mutex.Action {

        private long method = 0;

        private Object param1 = null;

        private Object param2 = null;

        private Object param3 = null;

        public Operation (long method) {

            this (method, null);

        }

        public Operation (long method, Object param1) {

            this (method, param1, null, null);

        }

        public Operation (long method, Object param1, Object param2, Object param3) {

            this.method = method;

            this.param1 = param1;

            this.param2 = param2;

            this.param3 = param3;

        }

        public Object run () {

            if (method == ProxyLook.GET_CHILD_OBJECTS) {

                return getLook ().getChildObjects (substitute);

            } else if (method == ProxyLook.GET_NAME) {

                return getLook ().getName (substitute);

            } else if (method == ProxyLook.SET_NAME) {

                getLook ().setName (substitute, (String) param1);

                return null;

            } else if (method == ProxyLook.GET_ICON) {

                return getLook ().getIcon (substitute, ((Integer) param1).intValue());

            } else if (method == ProxyLook.GET_HELP_CTX) {

                return getLook ().getHelpCtx (substitute);

            } else if (method == ProxyLook.GET_NEW_TYPES) {

                return getLook ().getNewTypes (substitute);

            } else if (method == ProxyLook.GET_ACTIONS) {

                return getLook ().getActions (substitute);

            } else if (method == ProxyLook.GET_CONTEXT_ACTIONS) {

                return getLook ().getContextActions (substitute);

            } else if (method == ProxyLook.GET_DEFAULT_ACTION) {

                return getLook ().getDefaultAction (substitute);

            } else if (method == ProxyLook.GET_PROPERTY_SETS) {

                return getLook ().getPropertySets (substitute);

            } else if (method == ProxyLook.GET_CUSTOMIZER) {

                return getLook ().getCustomizer (substitute);

            } else if (method == ProxyLook.HAS_CUSTOMIZER) {

                return getLook ().hasCustomizer (substitute) ? Boolean.TRUE : Boolean.FALSE;

            } else if (method == ProxyLook.CAN_RENAME) {

                return getLook ().canRename (substitute) ? Boolean.TRUE : Boolean.FALSE;

            } else if (method == ProxyLook.CAN_DESTROY) {

                return getLook ().canDestroy (substitute) ? Boolean.TRUE : Boolean.FALSE;

            } else if (method == ProxyLook.CAN_COPY) {

                return getLook ().canCopy (substitute) ? Boolean.TRUE : Boolean.FALSE;

            } else if (method == ProxyLook.CAN_CUT) {

                return getLook ().canCut (substitute) ? Boolean.TRUE : Boolean.FALSE;

            } else if (method == ProxyLook.GET_PASTE_TYPES) {

                return getLook ().getPasteTypes (substitute, (Transferable) param1);

            } else if (method == ProxyLook.GET_DROP_TYPE) {

                return getLook ().getDropType (substitute, (Transferable) param1, ((Integer) param2).intValue(), ((Integer) param2).intValue());

            }

            throw new IllegalStateException ("Invalid method id " + method); //NOI18N

        }

    }

    private final class OperationException implements Mutex.ExceptionAction {

        private long method = 0;

        public OperationException (long method) {

            this.method = method;

        }

        public Object run () throws IOException {

            if (method == ProxyLook.CLIPBOARD_COPY) {

                return getLook ().clipboardCopy (substitute);

            } else if (method == ProxyLook.CLIPBOARD_CUT) {

                return getLook ().clipboardCut (substitute);

            } else if (method == ProxyLook.DRAG) {

                return getLook ().drag (substitute);

            } else if (method == ProxyLook.DESTROY) {

                getLook ().destroy (substitute);

                return null;

            }