OpenIDE-Module-Module-Dependencies: org.netbeans.modules.editor.lib/1 = @BUILD_NUMBER_SUBST@, org.netbeans.modules.editor.fold/1, org.netbeans.modules.editor.lib/1, org.netbeans.modules.editor.util/1, org.openidex.util/3, org.openide.loaders > 4.11

    <p>

    The <code>org.netbeans.lib.editor.hyperlink.spi.HyperlinkProvider</code>

    instances can be registered by editors for the particular mime-types

    into <i>Editors/|mime-type|/HyperlinkProviders</i>.

    <br/>

    There can be multiple providers registered and their order

    will be respected during querying by the hyperlinking infrastructure

    (first provider which recognizes the given offset as a hyperlinking point

    will be used).

    </p>

OpenIDE-Module-Implementation-Version: @BUILD_NUMBER_SUBST@

                <package>org.netbeans.lib.editor.hyperlink.spi</package>

        c.putClientProperty("hyperlink-operation",

                org.netbeans.lib.editor.hyperlink.HyperlinkOperation.create(c, getContentType()));

/*

 *                 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-2004 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.lib.editor.hyperlink;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.netbeans.lib.editor.hyperlink.spi.HyperlinkProvider;

/**

 * Default implementation of the provider manager.

 * <br>

 * The default empty list of hyperlink providers

 * can be extended by registering new ones for each mimetype.

 *

 * @author Miloslav Metelka

 */

public class DefaultHyperlinkProviderManager extends HyperlinkProviderManager {

    private Map mimeType2providerList = new HashMap();

    /**

     * Register a new HyperlinkProvider.

     *

     * @param mimeType mime-type for which the provider is being registered.

     * @param provider provider to register.

     */

    public synchronized void addHyperlinkProvider(String mimeType, HyperlinkProvider provider) {

        getProviderList(mimeType, true).add(provider);

    }

    /**

     * Unregister a HyperlinkProvider.

     *

     * @param mimeType mime-type for which the provider is being unregistered.

     * @param provider provider to unregister.

     */

    public synchronized void removeHyperlinkProvider(String mimeType, HyperlinkProvider provider) {

        List providerList = getProviderList(mimeType, false);

        if (providerList != null) {

            providerList.remove(provider);

        }

    }

    public synchronized List/*<HyperlinkProvider>*/ getHyperlinkProviders(String mimeType) {

        List providers = getProviderList(mimeType, false);

        return (providers != null) ? providers : Collections.EMPTY_LIST;

    }

    private List getProviderList(String mimeType, boolean forceCreation) {

        List providerList = (List)mimeType2providerList.get(mimeType);

        if (providerList == null && forceCreation) {

            providerList = new ArrayList();

            mimeType2providerList.put(mimeType, providerList);

        }

        return providerList;

    }

}

/*

 *                 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-2004 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.lib.editor.hyperlink;

import java.awt.Color;

import java.awt.Cursor;

import java.awt.event.KeyEvent;

import java.awt.event.KeyListener;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import java.awt.event.MouseMotionListener;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import javax.swing.SwingUtilities;

import javax.swing.text.Document;

import javax.swing.text.JTextComponent;

import org.netbeans.editor.*;

import org.netbeans.lib.editor.hyperlink.spi.HyperlinkProvider;

/**

 *

 * @author Jan Lahoda

 */

public class HyperlinkOperation implements MouseListener, MouseMotionListener, PropertyChangeListener, KeyListener {

    private JTextComponent component;

    private Document       currentDocument;

    private HyperlinkLayer layer;

    private String         mimeType;

    private boolean        componentHadMouseCursor;

    private Cursor         oldComponentsMouseCursor;

    private boolean        hyperlinkUp;

    public static HyperlinkOperation create(JTextComponent component, String mimeType) {

        return new HyperlinkOperation(component, mimeType);

    }

    /** Creates a new instance of HoveringImpl */

    private HyperlinkOperation(JTextComponent component, String mimeType) {

        this.component = component;

        this.mimeType  = mimeType;

        this.oldComponentsMouseCursor = null;

        this.componentHadMouseCursor = false;

        this.hyperlinkUp = false;

        component.addPropertyChangeListener("document", this);

    }

    private void documentUpdated() {

        currentDocument = component.getDocument();

        if (currentDocument instanceof BaseDocument) {

            BaseDocument bd = (BaseDocument) currentDocument;

            bd.addLayer(layer = new HyperlinkLayer(), 1100);

            component.addMouseListener(this);

            component.addMouseMotionListener(this);

            component.addKeyListener(this);

        }

    }

    public void mouseMoved(MouseEvent e) {

        if ((e.getModifiersEx() & MouseEvent.CTRL_DOWN_MASK) == MouseEvent.CTRL_DOWN_MASK) {

            int position = component.viewToModel(e.getPoint());

            if (position < 0) {

                unHyperlink(true);

                return ;

            }

            performHyperlinking(position);

        } else {

            unHyperlink(true);

        }

    }

    public void mouseDragged(MouseEvent e) {

        //ignored

    }

    private void performHyperlinking(int position) {

        HyperlinkProvider provider = findProvider(position);

        if (provider != null) {

            int[] offsets = provider.getHyperlinkSpan(component.getDocument(), position);

            if (offsets != null)

                makeHyperlink(offsets[0], offsets[1]);

        } else {

            unHyperlink(true);

        }

    }

    private void performAction(int position) {

        HyperlinkProvider provider = findProvider(position);

        if (provider != null) {

            provider.performClickAction(component.getDocument(), position);

        }

    }

    private HyperlinkProvider findProvider(int position) {

        List/*<HyperlinkProvider>*/ providers = HyperlinkProviderManager.getDefault().getHyperlinkProviders(mimeType);

        for (Iterator/*<HyperlinkProvider>*/ i = providers.iterator(); i.hasNext(); ) {

            HyperlinkProvider provider = (HyperlinkProvider) i.next();

            if (provider.isHyperlinkPoint(component.getDocument(), position)) {

                return provider;

            }

        }

        return null;

    }

    private synchronized void makeHyperlink(final int start, final int end) {

        boolean makeCursorSnapshot = true;

        if (hyperlinkUp) {

            unHyperlink(false);

            makeCursorSnapshot = false;

        }

        hyperlinkUp = true;

        layer.hyperlinkStart = start;

        layer.hyperlinkEnd   = end;

        SwingUtilities.invokeLater(new Runnable() {

            public void run() {

                component.getUI().damageRange(component, start, end);

            }

        });

        if (makeCursorSnapshot) {

            if (componentHadMouseCursor = component.isCursorSet()) {

                oldComponentsMouseCursor = component.getCursor();

            } else {

                oldComponentsMouseCursor = null;

            }

            component.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        }

    }

    private synchronized void unHyperlink(boolean removeCursor) {

        if (!hyperlinkUp)

            return ;

        final int start = layer.hyperlinkStart;

        final int end   = layer.hyperlinkEnd;

        layer.hyperlinkStart = -1;

        layer.hyperlinkEnd   = -1;

        if (start != (-1) && end != (-1)) {

            SwingUtilities.invokeLater(new Runnable() {

                public void run() {

                    component.getUI().damageRange(component, start, end);

                }

            });

        }

        if (componentHadMouseCursor && removeCursor) {

            component.setCursor(oldComponentsMouseCursor);

            componentHadMouseCursor = false;

            oldComponentsMouseCursor = null;

        }

        hyperlinkUp = false;

    }

    public void propertyChange(PropertyChangeEvent evt) {

        if (currentDocument != component.getDocument())

            documentUpdated();

    }

    public void keyTyped(KeyEvent e) {

        //ignored

    }

    public void keyReleased(KeyEvent e) {

        if (e.getKeyCode() == KeyEvent.VK_CONTROL)

            unHyperlink(true);

    }

    public void keyPressed(KeyEvent e) {

        //ignored

    }

    public void mouseReleased(MouseEvent e) {

        //ignored

    }

    public void mousePressed(MouseEvent e) {

        //ignored

    }

    public void mouseExited(MouseEvent e) {

        //ignored

    }

    public void mouseEntered(MouseEvent e) {

        //ignored

    }

    public void mouseClicked(MouseEvent e) {

        if ((e.getModifiersEx() & MouseEvent.CTRL_DOWN_MASK) == MouseEvent.CTRL_DOWN_MASK) {

            int position = component.viewToModel(e.getPoint());

            if (position < 0) {

                return ;

            }

            performAction(position);

        }

    }

    private static class HyperlinkLayer extends DrawLayer.AbstractLayer {

        private int hyperlinkStart = (-1);

        private int hyperlinkEnd = (-1);

        public static final String NAME = "hyperlink-layer";

        public static final int VISIBILITY = 1050;

        private boolean initialized = false;

        public HyperlinkLayer() {

            super(NAME);

            this.initialized = false;

        }

        private void checkDocument(Document doc) {

        }

        public boolean extendsEOL() {

            return true;

        }

        public synchronized void init(final DrawContext ctx) {

            if (!initialized) {

                Document doc = ctx.getEditorUI().getDocument();

                initialized = true;

                checkDocument(doc);

            }

            if (isActive())

                setNextActivityChangeOffset(hyperlinkStart);

        }

        private boolean isActive() {

            return hyperlinkStart != (-1) && hyperlinkEnd != (-1);

        }

        public boolean isActive(DrawContext ctx, MarkFactory.DrawMark mark) {

            return isActive();

        }

        private boolean isIn(int offset) {

            return offset >= hyperlinkStart && offset < hyperlinkEnd;

        }

        private static Coloring hoverColoring = new Coloring(null, 0, Color.BLUE, null, Color.BLUE, null);

        public void updateContext(DrawContext ctx) {

            if (!isActive())

                return ;

            int currentOffset = ctx.getFragmentOffset();

            if (isIn(currentOffset)) {

                hoverColoring.apply(ctx);

                if (isIn(currentOffset + ctx.getFragmentLength()))

                    setNextActivityChangeOffset(currentOffset + ctx.getFragmentLength());

            }

        }

    }

}

/*

 *                 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-2004 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.lib.editor.hyperlink;

import java.util.List;

import org.openide.util.Lookup;

/**

 * This class provides a list of HyperlinkProvider(s) for a given mime type.

 * <br>

 * This class is first searched in the <code>Lookup</code>. If no implementation

 * is found then a default implementation {@link DefaultHyperlinkProviderManager}

 * is constructed.

 *

 * Besides the default implementation there is

 * {@link org.netbeans.modules.editor.hyperlink.LayerHyperlinkProviderManager}

 * in the editor module (non-library part)

 * which reads the hyperlink providers for the mime-types

 * from the xml layer in the System FS.

 * <br>

 * These two existing implementations should suffice for most uses.

 *

 * @author Jan Lahoda

 */

public abstract class HyperlinkProviderManager {

    private static HyperlinkProviderManager defaultManager;

    /**

     * Find the default hyperlink provider manager in the lookup (or construct

     * a simple default implementation if not found).

     *

     * @return non-null manager.

     */

    public static synchronized HyperlinkProviderManager getDefault() {

        if (defaultManager == null) {

            defaultManager = createDefault();

        }

        return defaultManager;

    }

    private static HyperlinkProviderManager createDefault() {

        HyperlinkProviderManager mgr = (HyperlinkProviderManager)Lookup.getDefault().

                lookup(HyperlinkProviderManager.class);

        if (mgr == null) { // not found in lookup -> use default

            mgr = new DefaultHyperlinkProviderManager();

        }

        return mgr;

    }

    /**

     * Provide List of HyperlinkProvider(s) for a given mime type.

     * 

     * @param mimeType mime type to test

     * @param List of HyperlinkProvider(s) for a given mime type.

     */

    public abstract List/*<HyperlinkProvider>*/ getHyperlinkProviders(String mimeType);

}

/*

 *                 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-2004 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.lib.editor.hyperlink.spi;

import javax.swing.text.Document;

/**

 * This interface should be implemented by anyone who whats to provide hyperlinking

 * functionality in the source code.

 * <br>

 * There should be one provider instance per mime-type.

 * Its methods are called for all the opened editors of the given mime-type

 * where the hyperlinking functionality gets requested.

 *

 * <p>

 * The providers need to be registered.

 * For NetBeans IDE, the default approach is to use System FileSystem.

 * <br>

 * The HyperlinkProvider(s) should be registered as ".instance" objects under

 * <code>Editors/&lt;mime-type&gt;/HyperlinkProviders</code> directory.

 * </p>

 * 

 * <p>

 * Please see {@link org.netbeans.lib.editor.hyperlink.HyperlinkProviderManager}

 * for more details.

 * </p>

 *

 * <p>

 * Note: there is no assurance on the order of calling of the methods in this class.

 * The callers may call the methods in any order and even do not call some of these methods

 * at all.

 * </p>

 *

 * @author Jan Lahoda

 * @since 1.0

 */

public interface HyperlinkProvider {

    /**

     * Should determine whether there should be a hyperlink on the given offset

     * in the given document. May be called any number of times for given parameters.

     * <br>

     * This method is called from event dispatch thread.

     * It should run very fast as it is called very often.

     *

     * @param doc document on which to operate.

     * @param offset >=0 offset to test (it generally should be offset < doc.getLength(), but

     *               the implementations should not depend on it)

     * @return true if the provided offset should be in a hyperlink

     *         false otherwise

     */

    boolean isHyperlinkPoint(Document doc, int offset);

    /**

     * Should determine the span of hyperlink on given offset. Generally, if

     * isHyperlinkPoint returns true for a given parameters, this class should

     * return a valid span, but it is not strictly required.

     * <br>

     * This method is called from event dispatch thread.

     * This method should run very fast as it is called very often.

     *

     * @param doc document on which to operate.

     * @param offset >=0 offset to test (it generally should be offset < doc.getLength(), but

     *               the implementations should not depend on it)

     * @return a two member array which contains starting and ending offset of a hyperlink

     *         that should be on a given offset

     */

    int[] getHyperlinkSpan(Document doc, int offset);

    /**

     * The implementor should perform an action

     * corresponding to clicking on the hyperlink on the given offset. The

     * nature of the action is given by the nature of given hyperlink, but

     * generally should open some resource or move cursor

     * to certain place in the current document.

     *

     * @param doc document on which to operate.

     * @param offset >=0 offset to test (it generally should be offset < doc.getLength(), but

     *               the implementations should not depend on it)

     */

    void performClickAction(Document doc, int offset);

}

org.netbeans.modules.editor.hyperlink.LayerHyperlinkProviderManager

/*

 *                 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-2004 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.modules.editor.hyperlink;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import org.netbeans.lib.editor.hyperlink.spi.HyperlinkProvider;

import org.netbeans.lib.editor.hyperlink.HyperlinkProviderManager;

import org.openide.ErrorManager;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.Repository;

import org.openide.loaders.DataObject;

import org.openide.loaders.DataObjectNotFoundException;

import org.openide.loaders.FolderLookup;

import org.openide.util.Lookup;

/**

 * Finds hyperlink providers in the System FileSystem. The HyperlinkProvider(s) should

 * be registered as ".instance" objects under <code>Editors/&lt;mime-type&gt;/HyperlinkProviders</code>

 * directory.

 *

 * @author Jan Lahoda

 */

public final class LayerHyperlinkProviderManager extends HyperlinkProviderManager {

    private Lookup lookup;

    /**

     * Creates a new instance of LayerHyperlinkProviderManager

     */

    public LayerHyperlinkProviderManager() {

    }

    public List/*<HyperlinkProvider>*/ getHyperlinkProviders(String mimeType) {

        FileObject hyperlinkProvidersFolder = Repository.getDefault().getDefaultFileSystem().

                findResource("Editors/" + mimeType + "/HyperlinkProviders");

        if (hyperlinkProvidersFolder!= null

                && !hyperlinkProvidersFolder.isData()

                && hyperlinkProvidersFolder.isValid()

                && !hyperlinkProvidersFolder.isVirtual()

        ) {

            try {

                DataObject od = DataObject.find(hyperlinkProvidersFolder);

                if (od instanceof DataObject.Container) {

                    FolderLookup flookup = new FolderLookup((DataObject.Container) od);

                    return Collections.unmodifiableList(

                        new ArrayList(flookup.getLookup().lookup(

                            new Lookup.Template(HyperlinkProvider.class)).allInstances()));

                }

            } catch (DataObjectNotFoundException e) {

                ErrorManager.getDefault().notify(e);

            }

        }

        return Collections.EMPTY_LIST;

    }

}

MODULE org.netbeans.modules.editor/3 (ide)

  REQUIRES org.netbeans.modules.editor.lib/1 (ide)

org.netbeans.lib.editor.hyperlink.spi

/*

 *                 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-2004 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.modules.java.editor.hyperlink;

import javax.swing.text.BadLocationException;

import javax.swing.text.Document;

import javax.swing.text.JTextComponent;

import org.netbeans.editor.BaseDocument;

import org.netbeans.editor.SyntaxSupport;

import org.netbeans.editor.TokenID;

import org.netbeans.editor.Utilities;

import org.netbeans.editor.ext.java.JavaTokenContext;

import org.netbeans.jmi.javamodel.ClassDefinition;

import org.netbeans.lib.editor.hyperlink.spi.HyperlinkProvider;

import org.openide.ErrorManager;

import org.netbeans.modules.editor.java.*;

/**

 * Implementation of the hyperlink provider for java language.

 * <br>

 * The hyperlinks are constructed for identifiers.

 * <br>

 * The click action corresponds to performing the goto-declaration action.

 *

 * @author Jan Lahoda

 */

public final class JavaHyperlinkProvider implements HyperlinkProvider {

    /** Creates a new instance of JavaHyperlinkProvider */

    public JavaHyperlinkProvider() {

    }

    public void performClickAction(Document originalDoc, int offset) {

        if (!(originalDoc instanceof BaseDocument))

            return ;

        BaseDocument doc = (BaseDocument) originalDoc;

        JTextComponent target = Utilities.getFocusedComponent();

        if (target.getDocument() != doc)

            return ;

        SyntaxSupport sup = doc.getSyntaxSupport();

        NbJavaJMISyntaxSupport nbJavaSup = (NbJavaJMISyntaxSupport)sup.get(NbJavaJMISyntaxSupport.class);

        JMIUtils jmiUtils = JMIUtils.get(doc);

        Object item = null;

        String itemDesc = null;

        jmiUtils.beginTrans(false);

        try {

            item = jmiUtils.findItemAtCaretPos(target);

            if (item instanceof NbJMIResultItem.VarResultItem) {

                int pos = nbJavaSup.findLocalDeclarationPosition(((NbJMIResultItem.VarResultItem)item).getItemText(), target.getCaretPosition());

                target.setCaretPosition(pos);

            } else {

                if (item instanceof ClassDefinition)

                    item = JMIUtils.getSourceElementIfExists((ClassDefinition)item);

                itemDesc = nbJavaSup.openSource(item, true);

            }

        } finally {

            jmiUtils.endTrans(false);

        }

    }

    public boolean isHyperlinkPoint(Document doc, int offset) {

        if (!(doc instanceof BaseDocument))

            return false;

        try {

            BaseDocument bdoc = (BaseDocument) doc;

            JTextComponent target = Utilities.getFocusedComponent();

            if (target.getDocument() != bdoc)

                return false;

            SyntaxSupport sup = bdoc.getSyntaxSupport();

            NbJavaJMISyntaxSupport nbJavaSup = (NbJavaJMISyntaxSupport)sup.get(NbJavaJMISyntaxSupport.class);

            TokenID token = nbJavaSup.getTokenID(offset);

            if (token == JavaTokenContext.IDENTIFIER)

                return true;

            return false;

        } catch (BadLocationException e) {

            ErrorManager.getDefault().notify(e);

            return false;

        }

    }

    public int[] getHyperlinkSpan(Document doc, int offset) {

        if (!(doc instanceof BaseDocument))

            return null;

        try {

            if (isHyperlinkPoint(doc, offset))

                return org.netbeans.editor.Utilities.getIdentifierBlock((BaseDocument) doc, offset);

            else

                return null;

        } catch (BadLocationException e) {

            ErrorManager.getDefault().notify(e);

            return null;

        }

    }

}

                <folder name="HyperlinkProviders">

                    <file name="JavaHyperlinkProvider.instance">

                        <attr name="instanceClass" stringvalue="org.netbeans.modules.java.editor.hyperlink.JavaHyperlinkProvider"/>

                        <attr name="instanceOf" stringvalue="org.netbeans.lib.editor.hyperlink.spi.HyperlinkProvider"/>

                    </file>

                </folder>