Attachment #149307 for bug #245014

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 245014
Collapse All | Expand All




                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>1.45</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.io.base</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <release-version>1</release-version>
                        <specification-version>1.0</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>




import java.awt.*;
import java.io.IOException;
import java.io.Reader;
import java.util.EnumSet;
import org.netbeans.core.output2.options.OutputOptions;
import org.openide.io.base.BaseColor;
import org.openide.io.base.BaseIOColorLines;
import org.openide.io.base.BaseIOColorPrint;
import org.openide.io.base.BaseIOColors;
import org.openide.io.base.BaseIOFolding;
import org.openide.io.base.BaseIOHyperlink;
import org.openide.io.base.BaseIOLinkInfo;
import org.openide.io.base.BaseIOPosition;
import org.openide.io.base.BaseIOSelect;
import org.openide.io.base.BaseIOTab;
import org.openide.io.base.BaseInputOutput;
import org.openide.io.base.BaseOutputEvent;
import org.openide.io.base.BaseOutputListener;
import org.openide.util.Exceptions;
import org.openide.util.Lookup;
import org.openide.util.lookup.Lookups;
import org.openide.windows.IOColorLines;
import org.openide.windows.IOColorPrint;
import org.openide.windows.IOColors;
import org.openide.windows.IOColors.OutputType;
import org.openide.windows.IOContainer;
import org.openide.windows.IOFolding;
import org.openide.windows.IOPosition;
import org.openide.windows.IOSelect;
import org.openide.windows.IOSelect.AdditionalOperation;
import org.openide.windows.IOTab;
import org.openide.windows.OutputEvent;

/** Implementation of InputOutput.  Implements calls as a set of
 * "commands" which are passed up to Dispatcher to be run on the event

 *
 * @author  Tim Boudreau
 */
class NbIO implements InputOutput, BaseInputOutput, Lookup.Provider {

    private Boolean focusTaken = null;
    private volatile boolean closed = false;

        return actions;
    }
    
    @Override
    public void reset() {
        if (Controller.LOG) Controller.log (this + ": reset");
        closed = false;

            ioColors = new IOColorsImpl();
            lookup = Lookups.fixed(ioTab, ioColors, new IOPositionImpl(),
                    new IOColorLinesImpl(), new IOColorPrintImpl(),
                    new IOSelectImpl(), new BaseIOSelectImpl(),
                    new IOFoldingImpl(), new BaseIOHyperlinkImpl(), options);
        }
        return lookup;
    }

        return ioColors != null ? ioColors.getColor(type) : AbstractLines.getDefColors()[type.ordinal()];
    }

    private class IOTabImpl extends IOTab implements BaseIOTab.Provider {
        Icon icon;
        String toolTip;


        }

        @Override
        public String getToolTipText() {
            return toolTip;
        }


        }

        @Override
        public void setToolTipText(String text) {
            toolTip = text;
            post(NbIO.this, IOEvent.CMD_SET_TOOLTIP, toolTip);
        }
    }

    private class IOPositionImpl extends IOPosition
            implements BaseIOPosition.Provider {

        @Override
        public PositionImpl currentPosition() {
            OutWriter out = out();
            int size = 0;
            if (out != null) {

        }
    }

    private class PositionImpl implements IOPosition.Position,
            BaseIOPosition.Position {
        private int pos;

        public PositionImpl(int pos) {

        }
    }

    private class IOColorLinesImpl extends IOColorLines implements BaseIOColorLines.Provider {

        @Override
        protected void println(CharSequence text, OutputListener listener, boolean important, Color color) throws IOException {

                out.print(text, listener, important, color, null, OutputKind.OUT, true);
            }
        }

        @Override
        public void println(CharSequence text, boolean important, BaseColor color,
                BaseIOLinkInfo... extendedInfo) throws IOException {
            OutWriter out = out();
            if (out != null) {
                OutputListener l = findAndConvertOutputListener(extendedInfo);
                out.print(text, l, important, convertToColor(color), null,
                        OutputKind.OUT, true);
            }
        }
    }

    private class IOColorPrintImpl extends IOColorPrint implements BaseIOColorPrint.Provider {

        @Override
        protected void print(CharSequence text, OutputListener listener, boolean important, Color color) throws IOException {

                out.print(text, listener, important, color, null, OutputKind.OUT, false);
            }
        }

        @Override
        public void print(CharSequence text, boolean important, BaseColor color,
                BaseIOLinkInfo... extendedInfo) throws IOException {
            OutWriter out = out();
            if (out != null) {
                OutputListener l = findAndConvertOutputListener(extendedInfo);
                out.print(text, l, important, convertToColor(color), null,
                        OutputKind.OUT, false);
            }
        }
    }

    private class IOSelectImpl extends IOSelect {

	}
    }

    private class BaseIOSelectImpl implements BaseIOSelect.Provider {

        @Override
        public void select(Set<BaseIOSelect.AdditionalOperation> extraOps) {
            if (Controller.LOG) {
                Controller.log(this + ": IOSelect.select");             //NOI18N
            }
            NbIO.post(NbIO.this, IOEvent.CMD_FINE_SELECT,
                    convertIOSelectOps(extraOps));
        }
    }

    private class IOColorsImpl extends IOColors implements BaseIOColors.Provider {
        Color[] clrs = new Color[OutputType.values().length];

        @Override

            clrs[type.ordinal()] = color;
            post(NbIO.this, IOEvent.CMD_DEF_COLORS, type);
        }

        @Override
        public BaseColor getColor(BaseIOColors.OutputType type) {
            return convertToBaseColor(getColor(convertOutputType(type)));
        };

        @Override
        public void setColor(BaseIOColors.OutputType type, BaseColor color) {
            setColor(convertOutputType(type), convertToColor(color));
        }
    }

    private class IOFoldingImpl extends IOFolding implements BaseIOFolding.Provider {

        @Override
        public NbIoFoldHandleDefinition startFold(boolean expanded) {
            synchronized (outOrException()) {
                if (currentFold != null) {
                    throw new IllegalStateException(

            }
        }

        class NbIoFoldHandleDefinition extends IOFolding.FoldHandleDefinition
            implements BaseIOFolding.FoldHandleDefinition{

            private final NbIoFoldHandleDefinition parent;
            private final int start;

            }

            @Override
            public NbIoFoldHandleDefinition startFold(boolean expanded) {
                synchronized (outOrException()) {
                    if (end != -1) {
                        throw new IllegalStateException(

        }
    }

    private class BaseIOHyperlinkImpl implements BaseIOHyperlink.Provider {

        @Override
        public boolean isSupported(Class<? extends BaseIOLinkInfo> cls) {
            return BaseOutputListener.class.isAssignableFrom(cls);
        }

        @Override
        public void println(BaseIOHyperlink.Type type, String s,
                boolean important, BaseIOLinkInfo... linkInfo) throws IOException {
            OutputWriter writer = BaseIOHyperlink.Type.ERR.equals(type)
                    ? getErr() : getOut();
            if (writer != null) {
                OutputListener l = findAndConvertOutputListener(linkInfo);
                writer.println(s, l, important);
            }
        }
    }

    private int getLastLineNumber() {
        return Math.max(0, out().getLines().getLineCount() - 2);
    }

    OutputOptions getOptions() {
        return this.options;
    }

    /**
     * Find the first {@link BaseOutputListener} in the list of hyperlink
     * extension objects, convert it to {@link OutputListener} and return it.
     */
    private OutputListener findAndConvertOutputListener(BaseIOLinkInfo... exts) {
        for (Object o : exts) {
            if (o instanceof BaseOutputListener) {
                return convertToOutputListener((BaseOutputListener) o);
            }
        }
        return null;
    }

    private OutputListener convertToOutputListener(final BaseOutputListener l) {
        return new OutputListener() {

            @Override
            public void outputLineSelected(OutputEvent ev) {
            }

            @Override
            public void outputLineAction(OutputEvent ev) {
                l.outputLineAction(convertToOutputEventBase(ev));
            }

            @Override
            public void outputLineCleared(OutputEvent ev) {
            }
        };
    }

    private BaseOutputEvent convertToOutputEventBase(final OutputEvent e) {
        InputOutput origIO = e.getInputOutput();
        BaseInputOutput src = origIO instanceof BaseInputOutput
                ? (BaseInputOutput) origIO : this;
        return new BaseOutputEvent(src) {
            @Override
            public String getLine() {
                return e.getLine();
            }
        };
    }

    private Set<AdditionalOperation> convertIOSelectOps(
            Set<BaseIOSelect.AdditionalOperation> ops) {
        Set<AdditionalOperation> s = EnumSet.noneOf(AdditionalOperation.class);
        for (BaseIOSelect.AdditionalOperation bo : ops) {
            switch (bo) {
                case OPEN:
                    s.add(AdditionalOperation.OPEN);
                    break;
                case REQUEST_ACTIVE:
                    s.add(AdditionalOperation.REQUEST_ACTIVE);
                    break;
                case REQUEST_VISIBLE:
                    s.add(AdditionalOperation.REQUEST_VISIBLE);
                    break;
            }
        }
        return s;
    }

    private OutputType convertOutputType(BaseIOColors.OutputType baseType) {
        switch (baseType) {
            case INPUT:
                return OutputType.INPUT;
            case OUTPUT:
                return OutputType.OUTPUT;
            case ERROR:
                return OutputType.ERROR;
            case HYPERLINK:
                return OutputType.HYPERLINK;
            case HYPERLINK_IMPORTANT:
                return OutputType.HYPERLINK_IMPORTANT;
            case LOG_DEBUG:
                return OutputType.LOG_DEBUG;
            case LOG_SUCCESS:
                return OutputType.LOG_SUCCESS;
            case LOG_WARNING:
                return OutputType.LOG_WARNING;
            case LOG_FAILURE:
                return OutputType.LOG_FAILURE;
            default:
                throw new IllegalArgumentException(
                        "Unknown output type " + baseType);             //NOI18N
        }
    }

    private Color convertToColor(BaseColor baseColor) {
        return new Color(baseColor.getRGB(), true);
    }

    private BaseColor convertToBaseColor(Color color) {
        return new BaseColor(color.getRGB(), true);
    }
}




package org.netbeans.core.output2;

import java.io.IOException;
import java.util.WeakHashMap;
import javax.swing.Action;
import org.openide.util.Exceptions;
import org.openide.util.NbBundle;

import org.openide.windows.OutputWriter;

/**
 * Supplies Output Window implementation through Lookup. Provider of I/O
 * instances for the org.openide.io (package org.openide.windows) API.
 *
 * @author Jesse Glick, Tim Boudreau
 */
@org.openide.util.lookup.ServiceProvider(service=org.openide.windows.IOProvider.class, position=100)
public final class NbIOProvider extends IOProvider {
    private static final WeakHashMap<IOContainer, PairMap> containerPairMaps =
            new WeakHashMap<IOContainer, PairMap>();

    private static final String STDOUT = NbBundle.getMessage(NbIOProvider.class,
        "LBL_STDOUT"); //NOI18N

    @Override
    public String getName() {
        return SharedProvider.getInstance().getName();
    }

    @Override
    public OutputWriter getStdOut() {
        if (Controller.LOG) {
            Controller.log("NbIOProvider.getStdOut");

    }
    
    
    @Override
    public InputOutput getIO(String name, boolean newIO) {
        return getIO (name, newIO, new Action[0], null);
    }

    }

    @Override
    public InputOutput getIO(String name, boolean newIO, Action[] actions,
            IOContainer ioContainer) {

        return SharedProvider.getInstance().getIO(name, newIO, actions,
                ioContainer);
    }

    static void dispose(NbIO io) {
        SharedProvider.dispose(io);
            Action[] toolbarActions, IOContainer ioContainer) {
        if (Controller.LOG) {
            Controller.log("GETIO: " + name + " new:" + newIO);
        }
        IOContainer realIoContainer = ioContainer == null
                ? IOContainer.getDefault() : ioContainer;
        NbIO result;
        synchronized (containerPairMaps) {
            PairMap namesToIos = containerPairMaps.get(realIoContainer);
            result = namesToIos != null ? namesToIos.get(name) : null;
        }
        if (result == null || newIO) {
            result = new NbIO(name, toolbarActions, realIoContainer);
            synchronized (containerPairMaps) {
                PairMap namesToIos = containerPairMaps.get(realIoContainer);
                if (namesToIos == null) {
                    namesToIos = new PairMap();
                    containerPairMaps.put(realIoContainer, namesToIos);
                }
                namesToIos.add(name, result);
            }
            NbIO.post(new IOEvent(result, IOEvent.CMD_CREATE, newIO));
        }
        return result;
    }
    
    
    static void dispose (NbIO io) {
        IOContainer ioContainer = io.getIOContainer();
        if (ioContainer == null) {
            ioContainer = IOContainer.getDefault();
        }
        synchronized (containerPairMaps) {
            PairMap namesToIos = containerPairMaps.get(ioContainer);
            if (namesToIos != null) {
                namesToIos.remove(io);
                if (namesToIos.isEmpty()) {
                    containerPairMaps.remove(ioContainer);
                }
            }
        }
    }
}





/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2014 Sun Microsystems, Inc.
 */
package org.netbeans.core.output2;

import java.util.EventListener;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.Action;
import org.openide.io.base.BaseIOProvider;
import org.openide.io.base.BaseInputOutput;
import org.openide.util.Lookup;
import org.openide.util.lookup.ServiceProvider;

/**
 * Provider of I/O instances for the org.openide.io.base API.
 *
 * @author jhavlin
 */
@ServiceProvider(service = BaseIOProvider.class, position = 100)
public class NbIOProviderBase extends BaseIOProvider {

    private static final Logger LOG = Logger.getLogger(
            NbIOProviderBase.class.getName());

    @Override
    public String getName() {
        return SharedProvider.getInstance().getName();
    }

    @Override
    public BaseInputOutput getIO(String name, boolean newIO,
            Lookup context, EventListener... actions) {

        Action[] actionArray = convertActions(actions);
        return SharedProvider.getInstance().getIO(name, newIO, actionArray,
                null);
    }

    private Action[] convertActions(EventListener[] actions) {
        Action[] actionArray = new Action[actions.length];
        for (int i = 0; i < actions.length; i++) {
            if (actions[i] instanceof Action) {
                actionArray[i] = (Action) actions[i];
            } else if (actions[i] == null) {
                LOG.log(Level.WARNING, "Null action",                   //NOI18N
                        new IllegalArgumentException());
                return new Action[0];
            } else {
                LOG.log(Level.WARNING, "Only actions of type javax."    //NOI18N
                        + "swing.Action are supported, but object of "  //NOI18N
                        + "type " + actions[i].getClass() + " found",   //NOI18N
                        new IllegalArgumentException());
                return new Action[0];
            }
        }
        return actionArray;
    }

    @Override
    public boolean isActionTypeSupported(
            Class<? extends EventListener> cls) {
        return Action.class.isAssignableFrom(cls);
    }
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2014 Sun Microsystems, Inc.
 */
package org.netbeans.core.output2;

import java.util.WeakHashMap;
import javax.swing.Action;
import org.openide.windows.IOContainer;

/**
 * Shared provider for both the original (org.openide.io/org.openide.windows)
 * and the base (org.openide.io.base) APIs.
 *
 * @author jhavlin
 */
public class SharedProvider {

    private static final WeakHashMap<IOContainer, PairMap> containerPairMaps
            = new WeakHashMap<IOContainer, PairMap>();
    private static final String NAME = "output2"; // NOI18N

    private static class SingletonHolder {

        static SharedProvider INSTANCE = new SharedProvider();
    }

    public static SharedProvider getInstance() {
        return SingletonHolder.INSTANCE;
    }

    private SharedProvider() {
        System.out.println("x");
    }

    public String getName() {
        return NAME;
    }

    NbIO getIO(String name, boolean newIO,
            Action[] toolbarActions, IOContainer ioContainer) {
        if (Controller.LOG) {
            Controller.log("GETIO: " + name + " new:" + newIO);
        }
        IOContainer realIoContainer = ioContainer == null
                ? IOContainer.getDefault() : ioContainer;
        NbIO result;
        synchronized (containerPairMaps) {
            PairMap namesToIos = containerPairMaps.get(realIoContainer);
            result = namesToIos != null ? namesToIos.get(name) : null;
        }
        if (result == null || newIO) {
            result = new NbIO(name, toolbarActions, realIoContainer);
            synchronized (containerPairMaps) {
                PairMap namesToIos = containerPairMaps.get(realIoContainer);
                if (namesToIos == null) {
                    namesToIos = new PairMap();
                    containerPairMaps.put(realIoContainer, namesToIos);
                }
                namesToIos.add(name, result);
            }
            NbIO.post(new IOEvent(result, IOEvent.CMD_CREATE, newIO));
        }
        return result;
    }

    static void dispose(NbIO io) {
        IOContainer ioContainer = io.getIOContainer();
        if (ioContainer == null) {
            ioContainer = IOContainer.getDefault();
        }
        synchronized (containerPairMaps) {
            PairMap namesToIos = containerPairMaps.get(ioContainer);
            if (namesToIos != null) {
                namesToIos.remove(io);
                if (namesToIos.isEmpty()) {
                    containerPairMaps.remove(ioContainer);
                }
            }
        }
    }
}

Lines 177-182 Link Here

(-)a/nbbuild/build.properties (+1 lines)
177	core.netigso,\	177	core.netigso,\
178	o.n.swing.outline,\	178	o.n.swing.outline,\
179	o.n.swing.tabcontrol,\	179	o.n.swing.tabcontrol,\
		180	openide.io.base,\
180	editor.indent,\	181	editor.indent,\
181	editor.bracesmatching,\	182	editor.bracesmatching,\
182	j2ee.metadata,\	183	j2ee.metadata,\

Lines 251-256 Link Here

(-)a/nbbuild/cluster.properties (+1 lines)
251	openide.filesystems.compat8,\	251	openide.filesystems.compat8,\
252	openide.filesystems.nb,\	252	openide.filesystems.nb,\
253	openide.io,\	253	openide.io,\
		254	openide.io.base,\
254	openide.loaders,\	255	openide.loaders,\
255	openide.nodes,\	256	openide.nodes,\
256	openide.options,\	257	openide.options,\




<?xml version="1.0" encoding="UTF-8"?>
<!--
DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

Copyright 2014 Oracle and/or its affiliates. All rights reserved.

Oracle and Java are registered trademarks of Oracle and/or its affiliates.
Other names may be trademarks of their respective owners.

The contents of this file are subject to the terms of either the GNU
General Public License Version 2 only ("GPL") or the Common
Development and Distribution License("CDDL") (collectively, the
"License"). You may not use this file except in compliance with the
License. You can obtain a copy of the License at
http://www.netbeans.org/cddl-gplv2.html
or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
specific language governing permissions and limitations under the
License.  When distributing the software, include this License Header
Notice in each file and include the License file at
nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
particular file as subject to the "Classpath" exception as provided
by Oracle in the GPL Version 2 section of the License file that
accompanied this code. If applicable, add the following below the
License Header, with the fields enclosed by brackets [] replaced by
your own identifying information:
"Portions Copyrighted [year] [name of copyright owner]"

If you wish your version of this file to be governed by only the CDDL
or only the GPL Version 2, indicate your decision by adding
"[Contributor] elects to include this software in this distribution
under the [CDDL or GPL Version 2] license." If you do not indicate a
single choice of license, a recipient has the option to distribute
your version of this file under either the CDDL, the GPL Version 2 or
to extend the choice of license to its licensees as provided above.
However, if you add GPL Version 2 code and therefore, elected the GPL
Version 2 license, then the option applies only if the new code is
made subject to such option by the copyright holder.

Contributor(s):

Portions Copyrighted 2014 Sun Microsystems, Inc.
-->

<?xml-stylesheet type="text/xml" href="../nbbuild/javadoctools/apichanges.xsl"?>
<!DOCTYPE apichanges PUBLIC "-//NetBeans//DTD API changes list 1.0//EN" "../nbbuild/javadoctools/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, as this is part of Javadoc generation; just
change the XML. 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>
        <apidef name="io.base">Base I/O APIs</apidef>
        <!-- etc. -->
    </apidefs>

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

    <changes>

        <!-- Start here... -->

    </changes>

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

    <htmlcontents>
<!-- Generated from apichanges.xml -->
    <head>
      <title>Change History for the Base I/O APIs</title>
      <link rel="stylesheet" href="prose.css" type="text/css"/>
    </head>
    <body>

<p class="overviewlink"><a href="@TOP@/overview-summary.html">Overview</a></p>

<h1>Introduction</h1>

<p>This document lists changes made to the <a href="@TOP@/overview-summary.html">Base I/O APIs</a>.</p>

<!-- The actual lists of changes, as summaries and details: -->
      <hr/>
      <standard-changelists module-code-name="org.openide.io.base/1"/>

      <hr/><p>@FOOTER@</p>

    </body>
  </htmlcontents>

</apichanges>





<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE api-answers PUBLIC "-//NetBeans//DTD Arch Answers//EN" "../nbbuild/antsrc/org/netbeans/nbbuild/Arch.dtd" [
  <!ENTITY api-questions SYSTEM "../nbbuild/antsrc/org/netbeans/nbbuild/Arch-api-questions.xml">
]>

<api-answers
  question-version="1.29"
  author="yourname@netbeans.org"
>

  &api-questions;


<!--
        <question id="arch-overall" when="init">
            Describe the overall architecture.
            <hint>
            What will be API for
            <a href="http://wiki.netbeans.org/API_Design#Separate_API_for_clients_from_support_API">
                clients and what support API</a>?
            What parts will be pluggable?
            How will plug-ins be registered? Please use <code>&lt;api type="export"/&gt;</code>
            to describe your general APIs and specify their
            <a href="http://wiki.netbeans.org/API_Stability#Private">
            stability categories</a>.
            If possible please provide simple diagrams.
            </hint>
        </question>
-->
 <answer id="arch-overall">
      <api
        name="BaseInputOutputAPI"
        group="java"
        type="export"
        category="devel"
        url="@org-openide-io-base@/org/openide/io/base/package-summary.html"
    >
        <p>
            Just a base API/SPI for defining the output window.
        </p>
    </api>
 </answer>



<!--
        <question id="arch-quality" when="init">
            How will the <a href="http://www.netbeans.org/community/guidelines/q-evangelism.html">quality</a>
            of your code be tested and
            how are future regressions going to be prevented?
            <hint>
            What kind of testing do
            you want to use? How much functionality, in which areas,
            should be covered by the tests? How you find out that your
            project was successful?
            </hint>
        </question>
-->
 <answer id="arch-quality">
  <p>
   Too little code to test.
  </p>
 </answer>



<!--
        <question id="arch-time" when="init">
            What are the time estimates of the work?
            <hint>
            Please express your estimates of how long the design, implementation,
            stabilization are likely to last. How many people will be needed to
            implement this and what is the expected milestone by which the work should be
            ready?
            </hint>
        </question>
-->
 <answer id="arch-time">
  <p>
   Done.
  </p>
 </answer>



<!--
        <question id="arch-usecases" when="init">
            <hint>
                Content of this answer will be displayed as part of page at
                http://www.netbeans.org/download/dev/javadoc/usecases.html
                You can use tags &lt;usecase name="name&gt; regular html description &lt;/usecase&gt;
                and if you want to use an URL you can prefix if with @TOP@ to begin
                at the root of your javadoc
            </hint>

            Describe the main <a href="http://wiki.netbeans.org/API_Design#The_Importance_of_Being_Use_Case_Oriented">
            use cases</a> of the new API. Who will use it under
            what circumstances? What kind of code would typically need to be written
            to use the module?
        </question>
-->
 <answer id="arch-usecases">
    <p>There is an SPI but additional implementations are not expected. The API is most important.</p>
    <p>
     Simple usage example:
    </p>
  <pre>
  <span class="type">BaseInputOutput</span> <span class="variable-name">io</span> = BaseIOProvider.getDefault().getIO(<span class="string">"My Window"</span>, true);
  <span class="type">PrintWriter</span> <span class="variable-name">w</span> = io.getOut();
  w.println(<span class="string">"Line of plain text."</span>);
  <span class="type">BaseOutputListener</span> <span class="variable-name">listener</span> = <span class="keyword">new</span> <span class="type">BaseOutputListener</span>() {
      <span class="keyword">public</span> <span class="type">void</span> <span class="function-name">outputLineAction</span>(<span class="type">BaseOutputEvent</span> <span class="variable-name">ev</span>) {
          StatusDisplayer.getDefault().setStatusText(<span class="string">"Hyperlink clicked!"</span>);
      }
  };
  if (BaseIOHyperlink.isSupported(io, <span class="type">BaseOutputListener</span>.class)) {
    BaseIOHyperlink.println(io, Type.OUT, <span class="string">"Line of hyperlinked text."</span>, true, listener);
  }
  </pre>
 </answer>



<!--
        <question id="arch-what" when="init">
            What is this project good for?
            <hint>
            Please provide here a few lines describing the project,
            what problem it should solve, provide links to documentation,
            specifications, etc.
            </hint>
        </question>
-->
 <answer id="arch-what">
  <p>
   The Base Input/Output APIs is a small API module
   which contains <code>BaseInputOutput</code> and related interfaces used in
   driving the Output Window. The normal implementation is
   <code>org.netbeans.core.output2</code>.
  </p>
  <p>
   The API was extracted from module openide.io, which depends on some
   GUI-related classes. This module has no such dependencies.
  </p>
 </answer>



<!--
        <question id="arch-where" when="impl">
            Where one can find sources for your module?
            <hint>
                Please provide link to the Hg web client at
                http://hg.netbeans.org/
                or just use tag defaultanswer generate='here'
            </hint>
        </question>
-->
 <answer id="arch-where">
  <defaultanswer generate='here' />
 </answer>



<!--
        <question id="compat-deprecation" when="init">
            How the introduction of your project influences functionality
            provided by previous version of the product?
            <hint>
            If you are planning to deprecate/remove/change any existing APIs,
            list them here accompanied with the reason explaining why you
            are doing so.
            </hint>
        </question>
-->
 <answer id="compat-deprecation">
  <p>
   This module is an alternative for org.openide.io, it has similar goals, but
   less dependencies.
  </p>
 </answer>



<!--
        <question id="compat-i18n" when="impl">
            Is your module correctly internationalized?
            <hint>
            Correct internationalization means that it obeys instructions
            at <a href="http://www.netbeans.org/download/dev/javadoc/org-openide-modules/org/openide/modules/doc-files/i18n-branding.html">
            NetBeans I18N pages</a>.
            </hint>
        </question>
-->
 <answer id="compat-i18n">
  <p>
   Yes.
  </p>
 </answer>



<!--
        <question id="compat-standards" when="init">
            Does the module implement or define any standards? Is the
            implementation exact or does it deviate somehow?
        </question>
-->
 <answer id="compat-standards">
  <p>
   The module defines an API.
  </p>
 </answer>



<!--
        <question id="compat-version" when="impl">
            Can your module coexist with earlier and future
            versions of itself? Can you correctly read all old settings? Will future
            versions be able to read your current settings? Can you read
            or politely ignore settings stored by a future version?

            <hint>
            Very helpful for reading settings is to store version number
            there, so future versions can decide whether how to read/convert
            the settings and older versions can ignore the new ones.
            </hint>
        </question>
-->
 <answer id="compat-version">
  <p>
   N/A
  </p>
 </answer>



<!--
        <question id="dep-jre" when="final">
            Which version of JRE do you need (1.2, 1.3, 1.4, etc.)?
            <hint>
            It is expected that if your module runs on 1.x that it will run
            on 1.x+1 if no, state that please. Also describe here cases where
            you run different code on different versions of JRE and why.
            </hint>
        </question>
-->
 <answer id="dep-jre">
  <p>
   1.7
  </p>
 </answer>



<!--
        <question id="dep-jrejdk" when="final">
            Do you require the JDK or is the JRE enough?
        </question>
-->
 <answer id="dep-jrejdk">
  <p>
   JRE
  </p>
 </answer>



<!--
        <question id="dep-nb" when="init">
            What other NetBeans projects and modules does this one depend on?
            <hint>
            Depending on other NetBeans projects influnces the ability of
            users of your work to customize their own branded version of
            NetBeans by enabling and disabling some modules. Too
            much dependencies restrict this kind of customization. If that
            is your case, then you may want to split your functionality into
            pieces of autoload, eager and regular modules which can be
            enabled independently. Usually the answer to this question
            is generated from your <code>project.xml</code> file, but
            if it is not guessed correctly, you can suppress it by
            specifying &lt;defaultanswer generate="none"/&gt; and
            write here your own. Please describe such projects as imported APIs using
            the <code>&lt;api name="identification" type="import or export" category="stable" url="where is the description" /&gt;</code>.
            By doing this information gets listed in the summary page of your
            javadoc.
            </hint>
        </question>
-->
 <answer id="dep-nb">
  <defaultanswer generate='here' />
 </answer>



<!--
        <question id="dep-non-nb" when="init">
            What other projects outside NetBeans does this one depend on?

            <hint>
            Depending on 3rd party libraries is always problematic,
            especially if they are not open source, as that complicates
            the licensing scheme of NetBeans. Please enumerate your
            external dependencies here, so it is correctly understood since
            the begining what are the legal implications of your project.
            Also please note that
            some non-NetBeans projects are packaged as NetBeans modules
            (see <a href="http://libs.netbeans.org/">libraries</a>) and
            it is preferred to use this approach when more modules may
            depend and share such third-party libraries.
            </hint>
        </question>
-->
 <answer id="dep-non-nb">
  <p>
   None.
  </p>
 </answer>



<!--
        <question id="dep-platform" when="init">
            On which platforms does your module run? Does it run in the same
            way on each?
            <hint>
            If you plan any dependency on OS or any usage of native code,
            please describe why you are doing so and describe how you envision
            to enforce the portability of your code.
            Please note that there is a support for <a href="http://www.netbeans.org/download/dev/javadoc/org-openide-modules/org/openide/modules/doc-files/api.html#how-os-specific">OS conditionally
            enabled modules</a> which together with autoload/eager modules
            can allow you to enable to provide the best OS aware support
            on certain OSes while providing compatibility bridge on the not
            supported ones.
            Also please list the supported
            OSes/HW platforms and mentioned the lovest version of JDK required
            for your project to run on. Also state whether JRE is enough or
            you really need JDK.
            </hint>
        </question>
-->
 <answer id="dep-platform">
  <p>
   Any
  </p>
 </answer>



<!--
        <question id="deploy-dependencies" when="final">
            What do other modules need to do to declare a dependency on this one,
            in addition to or instead of the normal module dependency declaration
            (e.g. tokens to require)?
            <hint>
                Provide a sample of the actual lines you would add to a module manifest
                to declare a dependency, for example OpenIDE-Module-Requires: some.token.
                If other modules should not depend on this module, or should just use a
                simple regular module dependency, you can just answer "nothing". If you
                intentionally expose a semistable API to clients using implementation
                dependencies, you should mention that here (but there is no need to give
                an example of usage).
            </hint>
        </question>
-->
 <answer id="deploy-dependencies">
  <p>
   You will very likely also want to declare
  </p>
  <pre>OpenIDE-Module-Requires: org.openide.io.base.BaseIOProvider</pre>
  <p>to ensure that an Output Window implementation is in fact enabled.</p>
 </answer>



<!--
        <question id="deploy-jar" when="impl">
            Do you deploy just module JAR file(s) or other files as well?
            <hint>
            Usually a module consist of one JAR file (perhaps with Class-Path
            extensions) and also a configuration file that enables it. If you
            have any other files, use
            &lt;api group="java.io.File" name="yourname" type="export" category="friend"&gt;...&lt;/api&gt;
            to define the location, name and stability of your files (of course
            changing "yourname" and "friend" to suit your needs).

            If it uses more than one JAR, describe where they are located, how
            they refer to each other.
            If it consist of module JAR(s) and other files, please describe
            what is their purpose, why other files are necessary. Please
            make sure that installation/uninstallation leaves the system
            in state as it was before installation.
            </hint>
        </question>
-->
 <answer id="deploy-jar">
  <p>
   Just the module JAR.
  </p>
 </answer>



<!--
        <question id="deploy-nbm" when="impl">
            Can you deploy an NBM via the Update Center?
            <hint>
            If not why?
            </hint>
        </question>
-->
 <answer id="deploy-nbm">
  <p>
   Yes
  </p>
 </answer>



<!--
        <question id="deploy-packages" when="init">
            Are packages of your module made inaccessible by not declaring them
            public?

            <hint>
            By default NetBeans build harness treats all packages are private.
            If you export some of them - either as public or friend packages,
            you should have a reason. If the reason is described elsewhere
            in this document, you can ignore this question.
            </hint>
        </question>
-->
 <answer id="deploy-packages">
  <p>
   No; only API classes are public.
  </p>
 </answer>



<!--
        <question id="deploy-shared" when="final">
            Do you need to be installed in the shared location only, or in the user directory only,
            or can your module be installed anywhere?
            <hint>
            Installation location shall not matter, if it does explain why.
            Consider also whether <code>InstalledFileLocator</code> can help.
            </hint>
        </question>
-->
 <answer id="deploy-shared">
  <p>
   Anywhere
  </p>
 </answer>



<!--
        <question id="exec-ant-tasks" when="impl">
            Do you define or register any ant tasks that other can use?

            <hint>
            If you provide an ant task that users can use, you need to be very
            careful about its syntax and behaviour, as it most likely forms an
	          API for end users and as there is a lot of end users, their reaction
            when such API gets broken can be pretty strong.
            </hint>
        </question>
-->
 <answer id="exec-ant-tasks">
  <p>
   No
  </p>
 </answer>



<!--
        <question id="exec-classloader" when="impl">
            Does your code create its own class loader(s)?
            <hint>
            A bit unusual. Please explain why and what for.
            </hint>
        </question>
-->
 <answer id="exec-classloader">
  <p>
   No
  </p>
 </answer>



<!--
        <question id="exec-component" when="impl">
            Is execution of your code influenced by any (string) property
            of any of your components?

            <hint>
            Often <code>JComponent.getClientProperty</code>, <code>Action.getValue</code>
            or <code>PropertyDescriptor.getValue</code>, etc. are used to influence
            a behavior of some code. This of course forms an interface that should
            be documented. Also if one depends on some interface that an object
            implements (<code>component instanceof Runnable</code>) that forms an
            API as well.
            </hint>
        </question>
-->
 <answer id="exec-component">
  <p>
   No
  </p>
 </answer>



<!--
        <question id="exec-introspection" when="impl">
            Does your module use any kind of runtime type information (<code>instanceof</code>,
            work with <code>java.lang.Class</code>, etc.)?
            <hint>
            Check for cases when you have an object of type A and you also
            expect it to (possibly) be of type B and do some special action. That
            should be documented. The same applies on operations in meta-level
            (Class.isInstance(...), Class.isAssignableFrom(...), etc.).
            </hint>
        </question>
-->
 <answer id="exec-introspection">
  <p>
   No
  </p>
 </answer>



<!--
        <question id="exec-privateaccess" when="final">
            Are you aware of any other parts of the system calling some of
            your methods by reflection?
            <hint>
            If so, describe the "contract" as an API. Likely private or friend one, but
            still API and consider rewrite of it.
            </hint>
        </question>
-->
 <answer id="exec-privateaccess">
  <p>
   No
  </p>
 </answer>



<!--
        <question id="exec-process" when="impl">
            Do you execute an external process from your module? How do you ensure
            that the result is the same on different platforms? Do you parse output?
            Do you depend on result code?
            <hint>
            If you feed an input, parse the output please declare that as an API.
            </hint>
        </question>
-->
 <answer id="exec-process">
  <p>
   No
  </p>
 </answer>



<!--
        <question id="exec-property" when="impl">
            Is execution of your code influenced by any environment or
            Java system (<code>System.getProperty</code>) property?
            On a similar note, is there something interesting that you
            pass to <code>java.util.logging.Logger</code>? Or do you observe
            what others log?
            <hint>
            If there is a property that can change the behavior of your
            code, somebody will likely use it. You should describe what it does
            and the <a href="http://wiki.netbeans.org/API_Stability">stability category</a>
            of this API. You may use
            <pre>
                &lt;api type="export" group="property" name="id" category="private" url="http://..."&gt;
                    description of the property, where it is used, what it influence, etc.
                &lt;/api&gt;
            </pre>
            </hint>
        </question>
-->
 <answer id="exec-property">
  <p>
   No
  </p>
 </answer>



<!--
        <question id="exec-reflection" when="impl">
            Does your code use Java Reflection to execute other code?
            <hint>
            This usually indicates a missing or insufficient API in the other
            part of the system. If the other side is not aware of your dependency
            this contract can be easily broken.
            </hint>
        </question>
-->
 <answer id="exec-reflection">
  <p>
   No
  </p>
 </answer>



<!--
        <question id="exec-threading" when="init">
            What threading models, if any, does your module adhere to? How the
            project behaves with respect to threading?
            <hint>
                Is your API threadsafe? Can it be accessed from any threads or
                just from some dedicated ones? Any special relation to AWT and
                its Event Dispatch thread? Also
                if your module calls foreign APIs which have a specific threading model,
                indicate how you comply with the requirements for multithreaded access
                (synchronization, mutexes, etc.) applicable to those APIs.
                If your module defines any APIs, or has complex internal structures
                that might be used from multiple threads, declare how you protect
                data against concurrent access, race conditions, deadlocks, etc.,
                and whether such rules are enforced by runtime warnings, errors, assertions, etc.
                Examples: a class might be non-thread-safe (like Java Collections); might
                be fully thread-safe (internal locking); might require access through a mutex
                (and may or may not automatically acquire that mutex on behalf of a client method);
                might be able to run only in the event queue; etc.
                Also describe when any events are fired: synchronously, asynchronously, etc.
                Ideas: <a href="http://core.netbeans.org/proposals/threading/index.html#recommendations">Threading Recommendations</a> (in progress)
            </hint>
        </question>
-->
 <answer id="exec-threading">
  <p>
   Should be thread safe.
  </p>
 </answer>



<!--
        <question id="format-clipboard" when="impl">
            Which data flavors (if any) does your code read from or insert to
            the clipboard (by access to clipboard on means calling methods on <code>java.awt.datatransfer.Transferable</code>?

            <hint>
            Often Node's deal with clipboard by usage of <code>Node.clipboardCopy, Node.clipboardCut and Node.pasteTypes</code>.
            Check your code for overriding these methods.
            </hint>
        </question>
-->
 <answer id="format-clipboard">
  <p>
   Plain Unicode text only.
  </p>
 </answer>



<!--
        <question id="format-dnd" when="impl">
            Which protocols (if any) does your code understand during Drag &amp; Drop?
            <hint>
            Often Node's deal with clipboard by usage of <code>Node.drag, Node.getDropType</code>.
            Check your code for overriding these methods. Btw. if they are not overridden, they
            by default delegate to <code>Node.clipboardCopy, Node.clipboardCut and Node.pasteTypes</code>.
            </hint>
        </question>
-->
 <answer id="format-dnd">
  <p>
   N/A
  </p>
 </answer>



<!--
        <question id="format-types" when="impl">
            Which protocols and file formats (if any) does your module read or write on disk,
            or transmit or receive over the network? Do you generate an ant build script?
            Can it be edited and modified?

            <hint>
            <p>
            Files can be read and written by other programs, modules and users. If they influence
            your behaviour, make sure you either document the format or claim that it is a private
            api (using the &lt;api&gt; tag).
            </p>

            <p>
            If you generate an ant build file, this is very likely going to be seen by end users and
            they will be attempted to edit it. You should be ready for that and provide here a link
            to documentation that you have for such purposes and also describe how you are going to
            understand such files during next release, when you (very likely) slightly change the
            format.
            </p>
            </hint>
        </question>
-->
 <answer id="format-types">
  <p>
   None
  </p>
 </answer>



<!--
        <question id="lookup-lookup" when="init">
            Does your module use <code>org.openide.util.Lookup</code>
            or any similar technology to find any components to communicate with? Which ones?

            <hint>
            NetBeans is build around a generic registry of services called
            lookup. It is preferable to use it for registration and discovery
            if possible. See
            <a href="http://www.netbeans.org/download/dev/javadoc/org-openide-util/org/openide/util/lookup/doc-files/index.html">
            The Solution to Comunication Between Components
            </a>. If you do not plan to use lookup and insist usage
            of other solution, then please describe why it is not working for
            you.
            <br/>
            When filling the final version of your arch document, please
            describe the interfaces you are searching for, where
            are defined, whether you are searching for just one or more of them,
            if the order is important, etc. Also classify the stability of such
            API contract. Use &lt;api group=&amp;lookup&amp; /&gt; tag, so
            your information gets listed in the summary page of your javadoc.
            </hint>
        </question>
-->
 <answer id="lookup-lookup">
  <code>BaseIOProvider.getDefault()</code> asks lookup for the first instance
  of itself. This is normally provided by <code>org.netbeans.core.output2</code>.
 </answer>



<!--
        <question id="lookup-register" when="final">
            Do you register anything into lookup for other code to find?
            <hint>
            Do you register using layer file or using a declarative annotation such as <code>@ServiceProvider</code>?
            Who is supposed to find your component?
            </hint>
        </question>
-->
 <answer id="lookup-register">
  <p>
   No
  </p>
 </answer>



<!--
        <question id="lookup-remove" when="final">
            Do you remove entries of other modules from lookup?
            <hint>
            Why? Of course, that is possible, but it can be dangerous. Is the module
            your are masking resource from aware of what you are doing?
            </hint>
        </question>
-->
 <answer id="lookup-remove">
  <p>
   No
  </p>
 </answer>



<!--
        <question id="perf-exit" when="final">
            Does your module run any code on exit?
        </question>
-->
 <answer id="perf-exit">
  <p>
   No
  </p>
 </answer>



<!--
        <question id="perf-huge_dialogs" when="final">
            Does your module contain any dialogs or wizards with a large number of
            GUI controls such as combo boxes, lists, trees, or text areas?
        </question>
-->
 <answer id="perf-huge_dialogs">
  <p>
   No
  </p>
 </answer>



<!--
        <question id="perf-limit" when="init">
            Are there any hard-coded or practical limits in the number or size of
            elements your code can handle?
            <hint>
                Most of algorithms have increasing memory and speed complexity
                with respect to size of data they operate on. What is the critical
                part of your project that can be seen as a bottleneck with
                respect to speed or required memory? What are the practical
                sizes of data you tested your project with? What is your estimate
                of potential size of data that would cause visible performance
                problems? Is there some kind of check to detect such situation
                and prevent "hard" crashes - for example the CloneableEditorSupport
                checks for size of a file to be opened in editor
                and if it is larger than 1Mb it shows a dialog giving the
                user the right to decide - e.g. to cancel or commit suicide.
            </hint>
        </question>
-->
 <answer id="perf-limit">
  <p>
   No
  </p>
 </answer>



<!--
        <question id="perf-mem" when="final">
            How much memory does your component consume? Estimate
            with a relation to the number of windows, etc.
        </question>
-->
 <answer id="perf-mem">
  <p>
   N/A
  </p>
 </answer>



<!--
        <question id="perf-menus" when="final">
            Does your module use dynamically updated context menus, or
            context-sensitive actions with complicated and slow enablement logic?
            <hint>
                If you do a lot of tricks when adding actions to regular or context menus, you can significantly
                slow down display of the menu, even when the user is not using your action. Pay attention to
                actions you add to the main menu bar, and to context menus of foreign nodes or components. If
                the action is conditionally enabled, or changes its display dynamically, you need to check the
                impact on performance. In some cases it may be more appropriate to make a simple action that is
                always enabled but does more detailed checks in a dialog if it is actually run.
            </hint>
        </question>
-->
 <answer id="perf-menus">
  <p>
   No
  </p>
 </answer>



<!--
        <question id="perf-progress" when="final">
            Does your module execute any long-running tasks?

            <hint>Long running tasks should never block
            AWT thread as it badly hurts the UI
            <a href="http://performance.netbeans.org/responsiveness/issues.html">
            responsiveness</a>.
            Tasks like connecting over
            network, computing huge amount of data, compilation
            be done asynchronously (for example
            using <code>RequestProcessor</code>), definitively it should
            not block AWT thread.
            </hint>
        </question>
-->
 <answer id="perf-progress">
  <p>
   No
  </p>
 </answer>



<!--
        <question id="perf-scale" when="init">
            Which external criteria influence the performance of your
            program (size of file in editor, number of files in menu,
            in source directory, etc.) and how well your code scales?
            <hint>
            Please include some estimates, there are other more detailed
            questions to answer in later phases of implementation.
            </hint>
        </question>
-->
 <answer id="perf-scale">
  <p>
    Scalability in GUI speed and memory consumption is probably limited only
    by the Output Window implementation.
  </p>
 </answer>



<!--
        <question id="perf-spi" when="init">
            How the performance of the plugged in code will be enforced?
            <hint>
            If you allow foreign code to be plugged into your own module, how
            do you enforce that it will behave correctly and quickly and will not
            negatively influence the performance of your own module?
            </hint>
        </question>
-->
 <answer id="perf-spi">
  <p>
   No special behavior.
  </p>
 </answer>



<!--
        <question id="perf-startup" when="final">
            Does your module run any code on startup?
        </question>
-->
 <answer id="perf-startup">
  <p>
   No
  </p>
 </answer>



<!--
        <question id="perf-wakeup" when="final">
            Does any piece of your code wake up periodically and do something
            even when the system is otherwise idle (no user interaction)?
        </question>
-->
 <answer id="perf-wakeup">
  <p>
   No
  </p>
 </answer>



<!--
        <question id="resources-file" when="final">
            Does your module use <code>java.io.File</code> directly?

            <hint>
            NetBeans provide a logical wrapper over plain files called
            <code>org.openide.filesystems.FileObject</code> that
            provides uniform access to such resources and is the preferred
            way that should be used. But of course there can be situations when
            this is not suitable.
            </hint>
        </question>
-->
 <answer id="resources-file">
   <p>No, but the implementation may.</p>
 </answer>



<!--
        <question id="resources-layer" when="final">
            Does your module provide own layer? Does it create any files or
            folders in it? What it is trying to communicate by that and with which
            components?

            <hint>
            NetBeans allows automatic and declarative installation of resources
            by module layers. Module register files into appropriate places
            and other components use that information to perform their task
            (build menu, toolbar, window layout, list of templates, set of
            options, etc.).
            </hint>
        </question>
-->
 <answer id="resources-layer">
  <p>
   No
  </p>
 </answer>



<!--
        <question id="resources-mask" when="final">
            Does your module mask/hide/override any resources provided by other modules in
            their layers?

            <hint>
            If you mask a file provided by another module, you probably depend
            on that and do not want the other module to (for example) change
            the file's name. That module shall thus make that file available as an API
            of some stability category.
            </hint>
        </question>
-->
 <answer id="resources-mask">
  <p>
   No
  </p>
 </answer>



<!--
        <question id="resources-preferences" when="final">
            Does your module uses preferences via Preferences API? Does your module use NbPreferences or
            or regular JDK Preferences ? Does it read, write or both ?
            Does it share preferences with other modules ? If so, then why ?
            <hint>
                You may use
                    &lt;api type="export" group="preferences"
                    name="preference node name" category="private"&gt;
                    description of individual keys, where it is used, what it
                    influences, whether the module reads/write it, etc.
                    &lt;/api&gt;
                Due to XML ID restrictions, rather than /org/netbeans/modules/foo give the "name" as org.netbeans.modules.foo.
                Note that if you use NbPreferences this name will then be the same as the code name base of the module.
            </hint>
        </question>
-->
 <answer id="resources-preferences">
  <p>
   No
  </p>
 </answer>



<!--
        <question id="resources-read" when="final">
            Does your module read any resources from layers? For what purpose?

            <hint>
            As this is some kind of intermodule dependency, it is a kind of API.
            Please describe it and classify according to
            <a href="http://wiki.netbeans.org/API_Design#What_is_an_API.3F">
            common stability categories</a>.
            </hint>
        </question>
-->
 <answer id="resources-read">
  <p>
   No
  </p>
 </answer>



<!--
        <question id="security-grant" when="final">
            Does your code grant additional rights to some other code?
            <hint>Avoid using a class loader that adds extra
            permissions to loaded code unless really necessary.
            Also note that your API implementation
            can also expose unneeded permissions to enemy code by
            calling AccessController.doPrivileged().</hint>
        </question>
-->
 <answer id="security-grant">
  <p>
   No
  </p>
 </answer>



<!--
        <question id="security-policy" when="final">
            Does your functionality require modifications to the standard policy file?
            <hint>Your code might pass control to third-party code not
            coming from trusted domains. This could be code downloaded over the
            network or code coming from libraries that are not bundled
            with NetBeans. Which permissions need to be granted to which domains?</hint>
        </question>
-->
 <answer id="security-policy">
  <p>
   No
  </p>
 </answer>

</api-answers>

Line 0 Link Here

(-)a/openide.io.base/build.xml (+5 lines)
	1	<?xml version="1.0" encoding="UTF-8"?>
	2	<project basedir="." default="netbeans" name="openide.io.base">
	3	<description>Builds, tests, and runs the project org.openide.io.base</description>
	4	<import file="../nbbuild/templates/projectized.xml"/>
	5	</project>

Line 0 Link Here

(-)a/openide.io.base/manifest.mf (+5 lines)
	1	Manifest-Version: 1.0
	2	OpenIDE-Module: org.openide.io.base/1
	3	OpenIDE-Module-Localizing-Bundle: org/openide/io/base/Bundle.properties
	4	OpenIDE-Module-Specification-Version: 1.0
	5

Line 0 Link Here

(-)a/openide.io.base/nbproject/project.properties (+4 lines)
	1	is.autoload=true
	2	javac.source=1.6
	3	javac.compilerargs=-Xlint -Xlint:-serial
	4	javadoc.arch=${basedir}/arch.xml




<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://www.netbeans.org/ns/project/1">
    <type>org.netbeans.modules.apisupport.project</type>
    <configuration>
        <data xmlns="http://www.netbeans.org/ns/nb-module-project/3">
            <code-name-base>org.openide.io.base</code-name-base>
            <module-dependencies>
                <dependency>
                    <code-name-base>org.netbeans.api.annotations.common</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <release-version>1</release-version>
                        <specification-version>1.24</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.util.base</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>9.1</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.util.lookup</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>8.25</specification-version>
                    </run-dependency>
                </dependency>
            </module-dependencies>
            <public-packages>
                <package>org.openide.io.base</package>
            </public-packages>
        </data>
    </configuration>
</project>




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2014 Sun Microsystems, Inc.
 */
package org.openide.io.base;

/**
 * Color for use in base I/O APIs. Extrected from java.awt.Color.
 *
 * @author jhavlin
 */
public final class BaseColor {

    private int value;

    /**
     * Creates an opaque sRGB color with the specified combined RGB value
     * consisting of the red component in bits 16-23, the green component in
     * bits 8-15, and the blue component in bits 0-7. The actual color used in
     * rendering depends on finding the best match given the color space
     * available for a particular output device. Alpha is defaulted to 255.
     *
     * @param rgb the combined RGB components
     * @see #getRed
     * @see #getGreen
     * @see #getBlue
     * @see #getRGB
     */
    public BaseColor(int rgb) {
        value = 0xff000000 | rgb;
    }

    /**
     * Creates an sRGB color with the specified combined RGBA value consisting
     * of the alpha component in bits 24-31, the red component in bits 16-23,
     * the green component in bits 8-15, and the blue component in bits 0-7. If
     * the <code>hasalpha</code> argument is <code>false</code>, alpha is
     * defaulted to 255.
     *
     * @param rgba the combined RGBA components
     * @param hasalpha <code>true</code> if the alpha bits are valid;
     * <code>false</code> otherwise
     * @see java.awt.image.ColorModel#getRGBdefault
     * @see #getRed
     * @see #getGreen
     * @see #getBlue
     * @see #getAlpha
     * @see #getRGB
     */
    public BaseColor(int rgba, boolean hasalpha) {
        if (hasalpha) {
            value = rgba;
        } else {
            value = 0xff000000 | rgba;
        }
    }

    /**
     * Creates an opaque sRGB color with the specified red, green, and blue
     * values in the range (0 - 255). The actual color used in rendering depends
     * on finding the best match given the color space available for a given
     * output device. Alpha is defaulted to 255.
     *
     * @throws IllegalArgumentException if <code>r</code>, <code>g</code> or
     * <code>b</code> are outside of the range 0 to 255, inclusive
     * @param r the red component
     * @param g the green component
     * @param b the blue component
     * @see #getRed
     * @see #getGreen
     * @see #getBlue
     * @see #getRGB
     */
    public BaseColor(int r, int g, int b) {
        this(r, g, b, 255);
    }

    /**
     * Creates an sRGB color with the specified red, green, blue, and alpha
     * values in the range (0 - 255).
     *
     * @throws IllegalArgumentException if <code>r</code>, <code>g</code>,
     * <code>b</code> or <code>a</code> are outside of the range 0 to 255,
     * inclusive
     * @param r the red component
     * @param g the green component
     * @param b the blue component
     * @param a the alpha component
     * @see #getRed
     * @see #getGreen
     * @see #getBlue
     * @see #getAlpha
     * @see #getRGB
     */
    public BaseColor(int r, int g, int b, int a) {
        value = ((a & 0xFF) << 24)
                | ((r & 0xFF) << 16)
                | ((g & 0xFF) << 8)
                | ((b & 0xFF));
    }

    /**
     * Returns the RGB value representing the color in the default sRGB
     * color model. (Bits 24-31 are alpha, 16-23 are red, 8-15 are green,
     * 0-7 are blue).
     *
     * @return the RGB value of the color in the default sRGB
     * <code>ColorModel</code>.
     * @see #getRed
     * @see #getGreen
     * @see #getBlue
     */
    public int getRGB() {
        return value;
    }

    /**
     * Returns the red component in the range 0-255 in the default sRGB space.
     *
     * @return the red component.
     * @see #getRGB
     */
    public int getRed() {
        return (getRGB() >> 16) & 0xFF;
    }

    /**
     * Returns the green component in the range 0-255 in the default sRGB space.
     *
     * @return the green component.
     * @see #getRGB
     */
    public int getGreen() {
        return (getRGB() >> 8) & 0xFF;
    }

    /**
     * Returns the blue component in the range 0-255 in the default sRGB space.
     *
     * @return the blue component.
     * @see #getRGB
     */
    public int getBlue() {
        return (getRGB()) & 0xFF;
    }

    /**
     * Returns the alpha component in the range 0-255.
     *
     * @return the alpha component.
     * @see #getRGB
     */
    public int getAlpha() {
        return (getRGB() >> 24) & 0xff;
    }
}




 * Portions Copyrighted 2013 Sun Microsystems, Inc.
 */

package org.openide.io.base;

import java.util.logging.Level;
import java.util.logging.Logger;
import org.netbeans.api.annotations.common.CheckForNull;
import org.openide.io.base.BaseIOFolding.FoldHandleDefinition;

/**
 * An object that refers to a fold in output window. It can be used to finish
 * the fold, or to create nested folds.
 *
 * @author jhavlin
 * @since openide.io/1.38
 */
public final class BaseFoldHandle {

    private final FoldHandleDefinition definition;
    private static final Logger LOG = Logger.getLogger(BaseFoldHandle.class.getName());
    private BaseFoldHandle currentChild;
    private boolean finished = false;

    BaseFoldHandle(FoldHandleDefinition definition) {
        this.definition = definition;
    }


     * @throws IllegalStateException if the fold has been already finished, or
     * if an unfinished nested fold exists.
     */
    public BaseFoldHandle startFold(boolean expanded) {
        currentChild = new BaseFoldHandle(definition.startFold(expanded));
        return currentChild;
    }


     *
     * @return True if {@link #finish()} or {@link #silentFinish()} has been
     * already called on this fold handle, false otherwise.
     *
     * @since openide.io/1.42
     */
    public boolean isFinished() {
        return finished;

     * unfinished.
     *
     * @return The last started nested fold. Can be null.
     *
     * @since openide.io/1.42
     */
    public @CheckForNull BaseFoldHandle getLastNestedFold() {
        return currentChild;
    }


     * returns null if the last nested fold has been already finished.
     *
     * @return The last unfinished nested fold or null.
     *
     *  @since openide.io/1.42
     */
    public @CheckForNull BaseFoldHandle getCurrentNestedFold() {
        return (currentChild != null && !currentChild.isFinished())
                ? currentChild
                : null;

     * handle has been already finished. If an unfinished child fold exists, it
     * will be finished too. Any exception that could happen will be caught and
     * logged.
     *
     * @since openide.io/1.42
     */
    public void silentFinish() {
        if (!finished) {

     * @param expanded True to expand the new fold, false to collapse it, parent
     * folds will not be collapsed/expanded.
     * @return The new fold handle, or null if it cannot be created.
     *
     *  @since openide.io/1.42
     */
    public @CheckForNull BaseFoldHandle silentStartFold(boolean expanded) {
        if (!finished) {
            if (currentChild != null && !currentChild.finished) {
                currentChild.silentFinish();




 * Portions Copyrighted 2008 Sun Microsystems, Inc.
 */

package org.openide.io.base;

import java.awt.Color;
import java.io.IOException;
import org.netbeans.api.annotations.common.NonNull;
import org.netbeans.api.annotations.common.NullAllowed;
import org.openide.util.Lookup;

/**
 * Line printing with custom color.
 * <p>
 * Client usage:
 * </p>
 * <pre>
 *  // print green line
 *  {@link BaseInputOutput} io = ...;
 *  if (BaseIOColorLines.isSupported(io)) {
 *      BaseIOColorLines.println(io, "Green line", Color.GREEN);
 *  }
 * </pre>
 * How to support {@link BaseIOColorLines} in own {@link BaseIOProvider} implementation:
 * <ul>
 *   <li> Implement some {@link Provider} of BaseIOColorLines.</li>
 *   <li> Place instance of {@link Provider} to {@link Lookup} provided by {@link BaseInputOutput}.</li>
 *   <li> Place instance of {@link IOColorLines} to {@link Lookup} provided by {@link InputOutput}
 * </ul>
 * @see BaseIOColors
 * @see BaseIOColorPrint
 * @author Tomas Holy, Jaroslav Havlin
 * @author Tomas Holy
 */
public final class BaseIOColorLines {

    private BaseIOColorLines() {}

    /**
     * Prints line with selected color.
     *
     * @param io IO to print to.
     * @param text A string to print to the tab.
     * @param color A color for the line of text (null allowed). If null is
     * passed default color (see {@link BaseIOColors}) is used.
     * @throws java.io.IOException if printing to the output fails.
     * @throws IllegalArgumentException if the I/O does not support this
     * feature.
     */
    public static void println(
            @NonNull BaseInputOutput io,
            @NonNull CharSequence text,
            @NullAllowed BaseColor color) throws IOException {
        println(io, text, false, color);
    }

    /**
     * Prints line with selected color
     *
     * @param io IO to print to.
     * @param text A string to print to the tab.
     * @param important Mark the line as important. Makes the UI respond
     * appropriately, eg. stop the automatic scrolling or highlight the
     * hyperlink.
     * @param color A color for the line of text (null allowed). If null is
     * passed default color (see {@link BaseIOColors}) is used.
     * @param extendedInfo Output listener, output tag, or similar objects. See
     * {@link BaseIOHyperlink}.
     * @throws java.io.IOException if printing to the output fails.
     * @throws IllegalArgumentException if the I/O does not support this
     * feature.
     */
    public static void println(
            @NonNull BaseInputOutput io,
            @NonNull CharSequence text,
            boolean important,
            @NullAllowed BaseColor color,
            @NonNull BaseIOLinkInfo... extendedInfo)
            throws IOException {

        ExtrasHelper.getExtras(io, BaseIOColorLines.Provider.class).println(
                text, important, color, extendedInfo);
    }


    /**
     * Checks whether this feature is supported for provided IO.
     * @param io IO to check on.
     * @return True if supported.
     */
    public static boolean isSupported(@NonNull BaseInputOutput io) {
        return ExtrasHelper.isSupported(io, BaseIOColorLines.Provider.class);
    }

    /**
     * SPI for implementing support for color printing.
     * @see BaseIOColorLines
     * @param text a string to print to the tab
     * @param listener a listener that will receive events about this line
     * @param important  important mark the line as important.
     *        Makes the UI respond appropriately, eg. stop the automatic scrolling
     *        or highlight the hyperlink.
     * @param color a color for the line of text (null allowed). If null is passed default color (see {@link IOColors}) is used.
     */
    public interface Provider {

        /**
         * Prints line with selected color
         *
         * @param text A string to print to the tab. or other extension type,
         * see {@link BaseIOHyperlink}. (null allowed)
         * @param important Mark the line as important. Makes the UI respond
         * appropriately, eg. stop the automatic scrolling or highlight the
         * hyperlink.
         * @param color A color for the line of text (null allowed). If null is
         * passed default color (see {@link BaseIOColors}) is used.
         * @param extendedInfo Output listener, output tag, or similar objects.
         * See {@link BaseIOHyperlink}.
         * @throws java.io.IOException if printing to the output fails.
         */
        void println(
                @NonNull CharSequence text,
                boolean important,
                @NullAllowed BaseColor color,
                @NonNull BaseIOLinkInfo... extendedInfo) throws IOException;
    }


    /**
     * Checks whether this feature is supported for provided IO
     * @param io IO to check on
     * @return true if supported
     */
    public static boolean isSupported(InputOutput io) {
        return find(io) != null;
    }

    /**
     * Prints line with selected color
     * @param text a string to print to the tab
     * @param listener a listener that will receive events about this line (null allowed)
     * @param important  important mark the line as important.
     *        Makes the UI respond appropriately, eg. stop the automatic scrolling
     *        or highlight the hyperlink.
     * @param color a color for the line of text (null allowed). If null is passed default color (see {@link IOColors}) is used.
     */
    abstract protected void println(CharSequence text, OutputListener listener, boolean important, Color color) throws IOException;
}




 * Portions Copyrighted 2009 Sun Microsystems, Inc.
 */

package org.openide.io.base;

import java.awt.Color;
import java.io.IOException;
import org.netbeans.api.annotations.common.NonNull;
import org.netbeans.api.annotations.common.NullAllowed;
import org.openide.util.Lookup;

/**
 * Text printing with custom color.
 * <p>
 * Client usage:
 * </p>
 * <pre>
  BaseInputOutput io = ...;
  BaseOutputListener l = ...;
  BaseOutputListener l2 = ...;
  if (BaseIOColorPrint.isSupported(io)) {
    BaseIOColorPrint.print(io, "Green text", Color.GREEN);
    BaseIOColorPrint.print(io, " orange hyperlink ", false, Color.ORANGE, l);
    BaseIOColorPrint.print(io, " green hyperlink\n", false, Color.GREEN, l2);
  }
 </pre>
 * How to support {@link BaseIOColorPrint} in own {@link BaseIOProvider} implementation:
 * <ul>
 *   <li> Implement some {@link Provider} of BaseIOColorPrint.</li>
 *   <li> Place instance of {@link Provider} to {@link Lookup} provided by {@link BaseInputOutput}.</li>
 *   <li> Place instance of {@link IOColorPrint} to {@link Lookup} provided by {@link InputOutput}
 * </ul>
 * @see BaseIOColors
 * @see BaseIOColorLines
 * @author Tomas Holy, Jaroslav Havlin
 * @author Tomas Holy
 */
public final class BaseIOColorPrint {

    private BaseIOColorPrint() {}
        if (io instanceof Lookup.Provider) {
            Lookup.Provider p = (Lookup.Provider) io;
            return p.getLookup().lookup(IOColorPrint.class);
        }
        return null;
    }

    /**
     * Prints text with selected color
     * @param io IO to print to.
     * @param text A string to print to the tab.
     * @param color A color for the text (null allowed). If null is passed
     * default color (see {@link BaseIOColors}) is used.
     * @throws java.io.IOException if printint to the output fails.
     * @throws IllegalArgumentException if the I/O does not support this
     * feature.
     */
    public static void print(
            @NonNull BaseInputOutput io,
            @NonNull CharSequence text,
            @NullAllowed BaseColor color) throws IOException {
        print(io, text, false, color);
    }

    /**
     * Prints text with selected color and add listener for it
     * @param io IO to print to.
     * @param text A string to print to the tab.
     * @param important  Mark the line as important.
     * @param important  important mark the line as important.
     *        Makes the UI respond appropriately, eg. stop the automatic scrolling
     *        or highlight the hyperlink.
     * @param color A color for the text (null allowed). If null is passed
     * default color (see {@link BaseIOColors}) is used.
     * @param extendedInfo Output listeners, output tags or similar objects, see
     * {@link BaseIOHyperlink}.
     * @throws java.io.IOException if writing to the output fails.
     * @throws IllegalArgumentException if the I/O does not support this
     * feature.
     */
    public static void print(
            @NonNull BaseInputOutput io,
            @NonNull CharSequence text,
            boolean important,
            @NullAllowed BaseColor color,
            @NonNull BaseIOLinkInfo... extendedInfo)
            throws IOException {

        ExtrasHelper.getExtras(io, BaseIOColorPrint.Provider.class).print(
                text, important, color, extendedInfo);
    }



     * @param io IO to check on
     * @return true if supported
     */
    public static boolean isSupported(@NonNull BaseInputOutput io) {
        return ExtrasHelper.isSupported(io, BaseIOColorPrint.Provider.class);
    }

    public interface Provider {

        /**
         * Prints text with selected color and optionaly add listener for it
         *
         * @param text A string to print to the tab.
         * @param important Mark the line as important. Makes the UI
         * respond appropriately, eg. stop the automatic scrolling or highlight
         * the hyperlink.
         * @param color A color for the text (null allowed). If null is passed
         * default color (see {@link BaseIOColors}) is used.
         * @param extendedInfo Output listener, output tag or similar objects,
         * see {@link BaseIOHyperlink}.
         * @throws java.io.IOException if writing to the output fails.
         */
        void print(
                @NonNull CharSequence text,
                boolean important,
                @NullAllowed BaseColor color,
                @NonNull BaseIOLinkInfo... extendedInfo) throws IOException;
    }
}




 * Portions Copyrighted 2008 Sun Microsystems, Inc.
 */

package org.openide.io.base;

import org.netbeans.api.annotations.common.CheckForNull;
import org.netbeans.api.annotations.common.NonNull;
import org.openide.util.Lookup;

/**
 * Settings of colors for normal, error, hyperlink, important hyperlink lines.
 * Change is global for text past and future.
 * <p>
 *   Client usage:
 * </p>
 * <pre>
   // set important hyperlink color to red
   BaseInputOutput io = ...;
   if (BaseIOColors.isSupported(io)) {
       BaseIOColors.setColor(io, BaseIOColors.OutputType.HYPERLINK_IMPORTANT, Color.RED);
   }
 </pre>
 * How to support {@link BaseIOColors} in own {@link BaseIOProvider} implementation:
 * <ul>
 *   <li> Implement some {@link Provider} of BaseIOColors.
 *   <li> Place instance of {@link BaseIOColors} to {@link Lookup} provided by {@link BaseInputOutput}.
 *   <li> Place instance of {@link IOColors} to {@link Lookup} provided by {@link InputOutput}
 * </ul>
 * @see BaseIOColorLines
 * @see BaseIOColorPrint
 * @author Tomas Holy, Jaroslav Havlin
 * @author Tomas Holy
 */
public final class BaseIOColors {

    private BaseIOColors() {}
        if (io instanceof Lookup.Provider) {
            Lookup.Provider p = (Lookup.Provider) io;
            return p.getLookup().lookup(IOColors.class);
        }
        return null;
    }

    /**
     * output types

    }

    /**
     * Gets current color for output.
     * @param io {@link BaseInputOutput} to operate on.
     * @param type Output type to get color for.
     * @return Current color for specified output type or null if not supported.
     */
    public static @CheckForNull BaseColor getColor(
            @NonNull BaseInputOutput io,
            @NonNull OutputType type) {

        Provider ioc = ExtrasHelper.find(io, BaseIOColors.Provider.class);
        return ioc != null ? ioc.getColor(type) : null;
    }

    /**
     * Sets specified color for output.
     *
     * @param io {@link BaseInputOutput} to operate on.
     * @param type Output type to set color for.
     * @param color New color for specified output type.
     */
    public static void setColor(
            @NonNull BaseInputOutput io,
            @NonNull OutputType type,
            @NonNull BaseColor color) {
        Provider ioc = ExtrasHelper.find(io, BaseIOColors.Provider.class);
        if (ioc != null) {
            ioc.setColor(type, color);
        }
    }

    /**
     * Checks whether this feature is supported for provided IO.
     *
     * @param io IO to check on.
     * @return True if supported.
     */
    public static boolean isSupported(@NonNull BaseInputOutput io) {
        return ExtrasHelper.isSupported(io, BaseIOColors.Provider.class);
    }

    /**
     * SPI for implementing support for output coloring.
     *
     * @see BaseIOColors
     */
    public interface Provider {

        /**
         * Gets current color for output.
         *
         * @param type Output type to get color for.
         * @return Current color for specified output.
         */
        @NonNull BaseColor getColor(@NonNull OutputType type);

        /**
         * Sets specified color for output
         *
         * @param type Output type to set color for.
         * @param color New color for specified output type.
         */
        void setColor(@NonNull OutputType type, @NonNull BaseColor color);
    }
}




 *
 * Portions Copyrighted 2013 Sun Microsystems, Inc.
 */
package org.openide.io.base;

import org.netbeans.api.annotations.common.CheckReturnValue;
import org.netbeans.api.annotations.common.NonNull;
import org.openide.util.Lookup;
import org.openide.util.Lookup.Provider;
import org.openide.util.Parameters;

/**

 * Client usage:
 * </p>
 * <pre>
 *  BaseInputOutput io = ...;
 *  if (!BaseIOFolding.isSupported(io)) {
 *    throw new Exception("Folding is not supported");
 *  }
 *  io.getOut().println("First Line - start of fold");
 *  BaseFoldHandle fold = BaseIOFolding.startFold(io, true);
 *  io.getOut().println("  Fold Content 1");
 *  io.getOut().println("  The first line of nested fold");
 *  BaseFoldHandle nestedFold = fold.startFold(true);
 *  io.getOut().println("     Nested fold content 1");
 *  nestedFold.finish();
 *  io.getOut().println("  Fold Content 2");

 *  io.getOut().println("Text outside of the fold.");
 * </pre>
 * <p>
 * How to support {@link BaseIOFolding} in own {@link BaseIOProvider} implementation:
 * </p>
 * <ul>
 * <li> Implement some {@link Provider} of BaseIOFolding</li>
 * {@link Provider}</li>
 * <li> Extend {@link IOFolding} and implement its abstract methods</li>
 * <li> Extend {@link FoldHandleDefinition}</li>
 * <li> Place instance of {@link Provider} to {@link Lookup} provided by
 * {@link BaseInputOutput}</li>
 * </ul>
 *
 * @author jhavlin
 * @since openide.io/1.38
 */
public final class BaseIOFolding {

    private BaseIOFolding() {}

    /**
     * Check whether an {@link BaseInputOutput} supports folding.
     *
     * @param io The {@link BaseInputOutput} to check.
     * @return True if {@link #startFold(BaseInputOutput, boolean)} can be used
     * with {@code io}, false otherwise.
     */
    public static boolean isSupported(@NonNull BaseInputOutput io) {
        Parameters.notNull("parent", io);                               //NOI18N
        return ExtrasHelper.isSupported(io, BaseIOFolding.Provider.class);
    }

    public interface Provider {

        /**
         * Create a fold handle definition for the current last line in the
         * output window.
         *
         * @param expanded Initial state of the fold.
         * @return FoldHandleDefinition for the fold handle. Never null.
         *
         * @throws IllegalStateException if the last fold hasn't been finished
         * yet.
         */
        @NonNull
        FoldHandleDefinition startFold(boolean expanded);
    }

    /**
     * Create a fold handle definition for the current last line in the output
     * window.
     *
     * @param expanded Initial state of the fold.
     * @return FoldHandleDefinition for the fold handle. Never null.
     *
     * @throws IllegalStateException if the last fold hasn't been finished yet.
     */
    @NonNull
    protected abstract FoldHandleDefinition startFold(boolean expanded);

    /**
     * Create a fold handle for the current last line in the output window.
     *
     * @param io {@link BaseInputOutput} to create the fold in.
     * @param expanded Initial state of the fold.
     * @return The fold handle that can be used to finish the fold or to create
     * nested folds.
     * @throws IllegalStateException if the last fold hasn't been finished yet.
     * @throws UnsupportedOperationException if folding is not supported by the
     * {@link BaseInputOutput} object.
     */
    @CheckReturnValue
    @NonNull
    public static BaseFoldHandle startFold(
            @NonNull BaseInputOutput io, boolean expanded) {

        Parameters.notNull("io", io);                                   //NOI18N
        BaseIOFolding.Provider folding = ExtrasHelper.getExtras(io,
                BaseIOFolding.Provider.class);

        return new BaseFoldHandle(folding.startFold(expanded));
        } else {
            return new FoldHandle(folding.startFold(expanded));
        }
    }

    /**
     * An SPI for creating custom FoldHandle implementations.
     */
    public interface FoldHandleDefinition {

        /**
         * Finish the fold at the current last line. Ensure that nested folds

         * @throws IllegalStateException if parent fold has been already
         * finished, or if there is an unfinished nested fold.
         */
        public void finish();

        /**
         * Start a new fold at the current last line. Ensure that the parent

         * @throws IllegalStateException if the fold has been already finished,
         * or if the last nested fold hasn't been finished yet.
         */
        public FoldHandleDefinition startFold(boolean expanded);

        /**
         * Set state of the fold.

         *
         * @param expanded True to expand the fold, false to collapse it.
         */
        public void setExpanded(boolean expanded);
    }
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2014 Sun Microsystems, Inc.
 */
package org.openide.io.base;

import java.io.IOException;
import org.netbeans.api.annotations.common.NonNull;
import org.openide.util.Lookup;

/**
 * Text printing with listeners, tags, or custom extension types.
 *
 * <p>
 * Client usage:
 * </p>
 * <pre>
  BaseInputOutput io = ...;
  BaseOutputListener l = ...;
  BaseOutputTag t = ...;

  // check only one extension type
  if (BaseIOHyperlink.isSupported(io, BaseOutputListener.class) {
    BaseIOHyperlink.println(io, "Link", false, l);
  }

  // to print a single line with several extensions
  if (BaseIOHyperlink.isSupported(io)) { //check extensions supported at all
    List&ltObject&gt exts = new LinkedList&lt;Object&gt;();
    if (BaseIOHyperlink.isSupported(io, BaseOutputListener.class)) {
      exts.add(new MyOutputListener());
    }
    if (BaseIOHyperlink.isSupported(io, BaseOutputTag.class)) {
      exts.add(new MyOutputTag());
    }
    BaseIOHyperlink.println(io, "Link 2", false, exts.toArray(new Object[exts.size()]));
  }

 </pre>
 * How to support {@link BaseIOHyperlink} in own {@link BaseIOProvider} implementation:
 * <ul>
 *   <li> Implement some {@link Provider} of BaseIOHyperlink.</li>
 *   <li> Place instance of {@link Provider} to {@link Lookup} provided by {@link BaseInputOutput}.</li>
 * </ul>
 *
 * @author Jaroslav Havlin
 */
public final class BaseIOHyperlink {

    private BaseIOHyperlink() {}

    public enum Type {

        OUT, ERR;
    }

    /**
     * Check whether BaseIOHyperlink extension is supported by the I/O.
     *
     * @param io The I/O to check for support of BaseIOHyperlink.
     * @return True if BaseIOHyperlink is supported by the I/O, false otherwise.
     */
    public static boolean isSupported(@NonNull BaseInputOutput io) {
        return ExtrasHelper.isSupported(io, BaseIOHyperlink.Provider.class);
    }

    /**
     * Print a line which will be displayed as a hyperlink, calling the action
     * specified in the array object if it is clicked.
     *
     * @param io I/O to print into.
     * @param type Type of output, standard or error.
     * @param str a string to print to the tab
     * @param important mark the line as important. Makes the UI respond
     * appropriately, eg. stop the automatic scrolling or highlight the
     * hyperlink.
     * @param linkInfo array containing extending info for the text, e.g.
     * an output listener and/or an output tag.
     * @throws IOException if the string could not be printed
     * @throws IllegalArgumentException if the I/O does not support this feature.
     */
    public static void println(
            @NonNull BaseInputOutput io,
            @NonNull Type type,
            @NonNull String str,
            boolean important,
            @NonNull BaseIOLinkInfo... linkInfo) throws IOException {
        ExtrasHelper.getExtras(io, BaseIOHyperlink.Provider.class).println(
                type, str, important, linkInfo);
    }

    /**
     * Print a line which will be displayed as a hyperlink, calling the action
     * specifided in the {@link Lookup} object if it is clicked, if the caret
     * enters it, or if the enter key is pressed over it.
     *
     * @param io I/O to print into.
     * @param type Type of output, standard or error.
     * @param str a string to print to the tab
     * @param linkInfo array containing extending info for the text, e.g.
     * an output listener and/or an output tag.
     * @throws IOException if the string could not be printed
     * @throws IllegalArgumentException if the I/O does not support this feature.
     */
    public static void println(
            @NonNull BaseInputOutput io,
            @NonNull Type type,
            @NonNull String str,
            @NonNull BaseIOLinkInfo... linkInfo) throws IOException {
        println(io, type, str, false, linkInfo);
    }

    /**
     * Check whether BaseIOHyperlink is supported by the I/O and that its lines
     * can be extended with link info of class {@code cls}.
     *
     * @param io I/O object to get extending types from.
     * @param cls The link info class that we want to check the support for.
     * @return True if the I/O supports {@link BaseIOHyperlink} and if it can be
     * extended with instances of class {@code cls}.
     */
    public static boolean isSupported(
            @NonNull BaseInputOutput io,
            @NonNull Class<? extends BaseIOLinkInfo> cls) {
        Provider p = ExtrasHelper.find(io, Provider.class);
        return p == null
                ? false
                : p.isSupported(cls);
    }

    /**
     * SPI for implementing support for {@link BaseIOHyperlink}.
     */
    public interface Provider {

        /**
         * Check whether passed class or interface is supported by this
         * implementation of BaseOutputWriter and can be put to the array passed
         * to
         * {@link #println(BaseIOHyperlink.Type, String, boolean, BaseIOLinkInfo...)}.
         *
         * @param cls Class or interface to check
         * @return True if class or interface {@code cls} is supported.
         */
        boolean isSupported(@NonNull Class<? extends BaseIOLinkInfo> cls);

        /**
         * Print a line which will be displayed as a hyperlink, calling the
         * action specifided in the array object if it is clicked.
         *
         * @param type Type of the output, {@link Type#OUT} for standard output,
         * {@link Type#ERR} for error output.
         * @param s a string to print to the tab
         * @param linkInfo array containing extending info for the text,
         * e.g. an output listener and/or an output tag.
         * @param important mark the line as important. Makes the UI respond
         * appropriately, eg. stop the automatic scrolling or highlight the
         * hyperlink.
         * @throws IOException if the string could not be printed.
         */
        void println(@NonNull Type type, @NonNull String s, boolean important,
                @NonNull BaseIOLinkInfo... linkInfo) throws IOException;
    }
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2014 Sun Microsystems, Inc.
 */
package org.openide.io.base;

/**
 * Marker interface for classes that can be used as extending link info for
 * {@link BaseIOHyperlink}.
 *
 * @author jhavlin
 */
public interface BaseIOLinkInfo {
}




 * Portions Copyrighted 2008 Sun Microsystems, Inc.
 */

package org.openide.io.base;

import org.netbeans.api.annotations.common.CheckForNull;
import org.netbeans.api.annotations.common.NonNull;
import org.openide.util.Lookup;

/**
 * Navigation (scrolling) in IO component.
 * <p>
 * Client usage:
 * </p>
 * <pre>
 BaseInputOutput io = ...;
 // store current position of IO
 Position pos = BaseIOPosition.currentPosition(io);
 ...
 // scroll to stored position
 pos.scrollTo();
 </pre> How to support {@link BaseIOPosition} in own {@link BaseIOProvider}
 * implementation:
 * <ul>
 * <li> Implement {@link Provider} and implement its methods.
 * <li> Place instance of {@link Provider} to {@link Lookup} provided by
 * {@link BaseInputOutput}
 * </ul>
 *
 * @author Tomas Holy, Jaroslav Havlin
 */
public final class BaseIOPosition {

    private BaseIOPosition() {}
        if (io instanceof Lookup.Provider) {
            Lookup.Provider p = (Lookup.Provider) io;
            return p.getLookup().lookup(IOPosition.class);
        }
        return null;
    }

    public interface Position {
        void scrollTo();


    /**
     * Gets current position (in number of chars) in IO
     * @param io IO to operate on.
     * @return Current position or null if not supported.
     */
    public static @CheckForNull Position currentPosition(
            @NonNull BaseInputOutput io) {

        Provider iop = ExtrasHelper.find(io, Provider.class);
        return iop != null ? iop.currentPosition() : null;
    }


     * @param io IO to check on
     * @return true if supported
     */
    public static boolean isSupported(BaseInputOutput io) {
        return ExtrasHelper.isSupported(io, Provider.class);
    }

    public interface Provider {

        /**
         * Gets current position in IO
         *
         * @return current position
         */
        Position currentPosition();
    }
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2014 Sun Microsystems, Inc.
 */
package org.openide.io.base;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.StringWriter;
import java.util.Collection;
import java.util.EventListener;
import org.netbeans.api.annotations.common.NonNull;
import org.netbeans.api.annotations.common.NullAllowed;
import org.openide.util.Lookup;

/**
 * A factory for IO tabs. To create a new tab to write to, call e.g.
 * <code>BaseIOProvider.getDefault().getIO("MyTab", false)</code> (pass true if
 * there may be an existing tab with the same name and you want to write to a
 * new tab).
 *
 * @author jhavlin
 */
public abstract class BaseIOProvider {

    public static @NonNull BaseIOProvider getDefault() {
        BaseIOProvider iopb = Lookup.getDefault().lookup(BaseIOProvider.class);
        if (iopb == null) {
            iopb = new Trivial();
        }
        return iopb;
    }

    /**
     * Gets BaseIOProvider of selected name or delegates to getDefault() if none
     * was found.
     *
     * @param name ID of provider.
     * @return The instance corresponding to provided name or default instance
     * if not found.
     */
    public static @NonNull BaseIOProvider get(@NonNull String name) {
        Collection<? extends BaseIOProvider> res = Lookup.getDefault().lookupAll(
                BaseIOProvider.class);
        for (BaseIOProvider iop : res) {
            if (iop.getName().equals(name)) {
                return iop;
            }
        }
        return getDefault();
    }

    /**
     * Gets name (ID) of provider
     *
     * @return name of provider
     */
    public abstract @NonNull String getName();

    /**
     * Get a named instance of {@link BaseInputOutput}, which represents an
     * output tab in the output window. Streams for reading/writing can be
     * accessed via getters on the returned instance.
     *
     * @param name A localised display name for the tab.
     * @param newIO If <tt>true</tt>, a new {@link BaseInputOutput} is returned,
     * else an existing {@link BaseInputOutput} of the same name may be
     * returned.
     * @param context Various context objects that may be required by specific
     * implementations of the provider.
     * @param actions Objects that specify actions available in the I/O tab,
     * usually {@link javax.swing.Action} instances, possibly
     * {@link BaseOutputTag} instances, depending on what the BaseIOProvider
     * supports.
     * @return An {@link BaseInputOutput} instance for accessing the new tab.
     * @see BaseInputOutput
     */
    public abstract @NonNull
    BaseInputOutput getIO(
            @NonNull String name, boolean newIO,
            @NullAllowed Lookup context, EventListener... actions);

    /**
     * Check whether this implementation supports action type {@code cls}.
     *
     * @param cls Action type to check the support for.
     *
     * @return True if the passed type can be used for specifying actions for
     * the output tab, false if the passed type is not supported.
     *
     * @see #getIO(java.lang.String, boolean, java.util.EventListener...)
     */
    public abstract boolean isActionTypeSupported(
            @NonNull Class<? extends EventListener> cls);

    /**
     * Fallback implementation.
     */
    private static final class Trivial extends BaseIOProvider {

        private static final Reader in = new BufferedReader(
                new InputStreamReader(System.in));
        private static final PrintStream out = System.out;
        private static final PrintStream err = System.err;

        public Trivial() {
        }

        @Override
        public String getName() {
            return "Trivial";                                           //NOI18N
        }

        @Override
        public BaseInputOutput getIO(String name, boolean newIO,
                Lookup context, EventListener... actions) {
            return new TrivialIO(name);
        }

        @Override
        public boolean isActionTypeSupported(
                Class<? extends EventListener> cls) {
            return false;
        }

        @SuppressWarnings("deprecation")
        private final class TrivialIO implements BaseInputOutput {

            private final String name;

            public TrivialIO(String name) {
                this.name = name;
            }

            @Override
            public Reader getIn() {
                return in;
            }

            @Override
            public PrintWriter getOut() {
                return new TrivialOW(out, name);
            }

            @Override
            public PrintWriter getErr() {
                return new TrivialOW(err, name);
            }

            public Reader flushReader() {
                return getIn();
            }

            @Override
            public boolean isClosed() {
                return false;
            }

            @Override
            public void closeInputOutput() {
            }

            @Override
            public void reset() {
            }

            @Override
            public Lookup getLookup() {
                return Lookup.EMPTY;
            }
        }

        private static final class TrivialOW extends PrintWriter {

            private static int count = 0;
            private final String name;
            private final PrintStream stream;

            @SuppressWarnings("ValueOfIncrementOrDecrementUsed")
            public TrivialOW(PrintStream stream, String name) {
                // XXX using super(new PrintWriter(stream)) does not seem to work for some reason!
                super(new StringWriter());
                this.stream = stream;
                if (name != null) {
                    this.name = name;
                } else {
                    this.name = "anon-" + ++count; // NOI18N
                }
            }

            private void prefix(boolean hyperlink) {
                if (hyperlink) {
                    stream.print("[" + name + "]* "); // NOI18N
                } else {
                    stream.print("[" + name + "]  "); // NOI18N
                }
            }

            @Override
            public void println(float x) {
                prefix(false);
                stream.println(x);
            }

            @Override
            public void println(double x) {
                prefix(false);
                stream.println(x);
            }

            @Override
            public void println() {
                prefix(false);
                stream.println();
            }

            @Override
            public void println(Object x) {
                prefix(false);
                stream.println(x);
            }

            @Override
            public void println(int x) {
                prefix(false);
                stream.println(x);
            }

            @Override
            public void println(char x) {
                prefix(false);
                stream.println(x);
            }

            @Override
            public void println(long x) {
                prefix(false);
                stream.println(x);
            }

            @Override
            @SuppressWarnings("ImplicitArrayToString")
            public void println(char[] x) {
                prefix(false);
                stream.println(x);
            }

            @Override
            public void println(boolean x) {
                prefix(false);
                stream.println(x);
            }

            @Override
            public void println(String x) {
                prefix(false);
                stream.println(x);
            }

            @Override
            public void write(int c) {
                stream.write(c);
            }

            @Override
            public void write(char[] buf, int off, int len) {
                String s = new String(buf, off, len);
                if (s.endsWith("\n")) {
                    println(s.substring(0, s.length() - 1));
                } else {
                    try {
                        stream.write(s.getBytes());
                    } catch (IOException x) {
                    }
                }
            }

            @Override
            public void write(String s, int off, int len) {
                String sub = s.substring(off, off + len);
                if (sub.endsWith("\n")) {
                    println(sub.substring(0, sub.length() - 1));
                } else {
                    try {
                        stream.write(sub.getBytes());
                    } catch (IOException x) {
                    }
                }
            }
        }
    }
}




 * Portions Copyrighted 2010 Sun Microsystems, Inc.
 */

package org.openide.io.base;

import java.util.Set;
import org.netbeans.api.annotations.common.NonNull;
import org.openide.util.Parameters;

/**
 * Capability of an {@link BaseInputOutput} of fine grained selection of a
 * component.
 *
 * @author ivan, Jaroslav Havlin
 * @since 1.23
 */
public final class BaseIOSelect {

    private BaseIOSelect() {}

    /**
     * Additional operations to perform when selecting the output tab.
     * @author ivan
     */
    public static enum AdditionalOperation {
        /**
         * Additionally issue open() on the TopComponent containing the
         * {@link BaseInputOutput}.
         */
	OPEN,

	/**
	 * Additionally issue requestVisible() on the TopComponent containing
         * the {@link BaseInputOutput}.
	 */
	REQUEST_VISIBLE,

	/**
	 * Additionally issue requestActive() on the TopComponent containing
         * the {@link BaseInputOutput}.
	 */
	REQUEST_ACTIVE
    }

    private static IOSelect find(InputOutput io) {
        if (io instanceof Lookup.Provider) {
            Lookup.Provider p = (Lookup.Provider) io;
            return p.getLookup().lookup(IOSelect.class);
        }
        return null;
    }

    /**
     * With an empty 'extraOps' simply selects this io
     * without involving it's containing TopComponent.
     * <p>
     * For example:
     * </p>
     * <pre>
     * if (BaseIOSelect.isSupported(io) {
     *     BaseIOSelect.select(io, EnumSet.noneOf(IOSelect.AdditionalOperation.class));
     * }
     * </pre>
     * <p>
     * If this capability is not supported then no operation will be performed.
     * </p>
     * @param io {@link BaseInputOutput} to operate on.
     * @param extraOps Additional operations to apply to the containing
     * TopComponent.
     */
    public static void select(BaseInputOutput io, Set<AdditionalOperation> extraOps) {
	Parameters.notNull("extraOps", extraOps);	// NOI18N
	Provider ios = ExtrasHelper.find(io, Provider.class);
	if (ios != null) {
            ios.select(extraOps);
        }
	    io.select();	// fallback
    }

    /**

     * @param io IO to check on
     * @return true if supported
     */
    public static boolean isSupported(BaseInputOutput io) {
        return ExtrasHelper.isSupported(io, Provider.class);
    }

    public interface Provider {

        /**
         * With an empty 'extraOps' simply selects this io without involving
         * it's containing TopComponent.
         *
         * @param extraOps Additional operations to apply to the containing
         * TopComponent.
         */
        void select(@NonNull Set<AdditionalOperation> extraOps);
    }
}




 * Portions Copyrighted 2008 Sun Microsystems, Inc.
 */

package org.openide.io.base;

import org.netbeans.api.annotations.common.CheckForNull;
import org.netbeans.api.annotations.common.NonNull;
import org.netbeans.api.annotations.common.NullAllowed;
import org.openide.util.Lookup;

/**

 * Client usage:
 * <pre>
 *  // settings of IO tab icon, tooltip
 *  BaseInputOutput io = ...;
 *  BaseIOTab.setToolTipText(io, "text");
 *  IOTab.setIcon(io, icon);
 *  IOTab.setToolTipText(io, "text");
 * </pre>
 * How to support {@link BaseIOTab} in own {@link BaseIOProvider} implementation:
 * <ul>
 *   <li> Implement {@link Provider}.</li>
 *   <li> Place instance of {@link Provider} to {@link Lookup} provided by {@link BaseInputOutput}.</li>
 *   <li> Place instance of {@link IOTab} to {@link Lookup} provided by {@link InputOutput}
 * </ul>
 * @author Tomas Holy, Jaroslav Havlin
 * @author Tomas Holy
 */
public final class BaseIOTab {
    private static IOTab find(InputOutput io) {
        if (io instanceof Lookup.Provider) {
            Lookup.Provider p = (Lookup.Provider) io;
            return p.getLookup().lookup(IOTab.class);
        }
        return null;
    }

    private BaseIOTab() {}
     * Gets current tab icon for specified IO
     * @param io IO to operate on
     * @return current tab icon or null if not supported
     */
    public static Icon getIcon(InputOutput io) {
        IOTab iot = find(io);
        return iot != null ? iot.getIcon() : null;
    }

    /**
     * Sets icon to tab corresponding to specified IO
     * @param io IO to operate on
     * @param icon tab icon
     */
    public static void setIcon(InputOutput io, Icon icon) {
        IOTab iot = find(io);
        if (iot != null) {
            iot.setIcon(icon);
        }
    }

    /**
     * Gets current tool tip text for specified IO
     * @param io IO to operate on.
     * @return Current tool tip text or null if not supported.
     */
    public static @CheckForNull String getToolTipText(
            @NonNull BaseInputOutput io) {

        Provider iot = ExtrasHelper.find(io, Provider.class);
        return iot != null ? iot.getToolTipText() : null;
    }

    /**
     * Sets tool tip text to tab corresponding to specified IO
     * @param io IO to operate on.
     * @param text New tool tip text.
     */
    public static void setToolTipText(
            @NonNull BaseInputOutput io,
            @NullAllowed String text) {
        Provider iot = ExtrasHelper.find(io, Provider.class);
        if (iot != null) {
            iot.setToolTipText(text);
        }


    /**
     * Checks whether this feature is supported for provided IO
     * @param io IO to check on.
     * @return True if supported.
     */
    public static boolean isSupported(BaseInputOutput io) {
        return ExtrasHelper.isSupported(io, Provider.class);
    }

    /**
     * SPI for implementation of {@link BaseIOTab} support.
     * @return current tab icon
     */
    public interface Provider {

        /**
         * Gets current tool tip text.
         *
         * @return Current tool tip text.
         */
        @CheckForNull String getToolTipText();

        /**
         * Sets tool tip text to tab.
         *
         * @param text New tool tip text.
         */
        void setToolTipText(@NullAllowed String text);
    }
     * Gets current tool tip text
     * @return current tool tip text
     */
    abstract protected String getToolTipText();

    /**
     * Sets tool tip text to tab
     * @param text new tool tip text
     */
    abstract protected void setToolTipText(String text);
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2014 Sun Microsystems, Inc.
 */
package org.openide.io.base;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.Reader;
import org.openide.util.Lookup;

/**
 * An I/O connection to one tab on the Output Window. To acquire an instance to
 * write to, call, e.g.,
 * <code>BaseIOProvider.getDefault().getIO("someName", false)</code>. To get
 * actual streams to write to, call <code>getOut()</code> or <code>
 * getErr()</code> on the returned instance.
 * <p>
 * Generally it is preferable not to hold a reference to an instance of
 * {@link org.openide.io.base.BaseInputOutput}, but rather to fetch it by name
 * from {@link org.openide.io.base.BaseIOProvider} as needed.
 * </p>
 *
 * @author Ian Formanek, Jaroslav Tulach, Petr Hamernik, Ales Novak, Jan
 * Jancura, Jaroslav Havlin
 */
public interface BaseInputOutput extends Lookup.Provider {

    /**
     * Acquire an output writer to write to the tab. This is the usual use of a
     * tab--it writes to the main output pane.
     *
     * @return the writer
     */
    public PrintWriter getOut();

    /**
     * Get a reader to read from the tab. If a reader is ever requested, an
     * input line is added to the tab and used to read one line at a time.
     *
     * @return the reader
     */
    public Reader getIn();

    /**
     * Get an output writer to write to the tab in error mode. This might show
     * up in a different color than the regular output, e.g., or appear in a
     * separate pane.
     *
     * @return the writer
     */
    public PrintWriter getErr();

    /**
     * Closes this tab. The effect of calling any method on an instance of
     * {@link BaseInputOutput} after calling {@link #closeInputOutput()} on it
     * is undefined.
     */
    public void closeInputOutput();

    /**
     * Test whether this tab has been closed, either by a call to
     * <code>closeInputOutput()</code> or by the user closing the tab in the UI.
     *
     * @see #closeInputOutput
     * @return <code>true</code> if it is closed
     */
    public boolean isClosed();

    /**
     * Clean the output area.
     * @throws java.io.IOException
     */
    void reset() throws IOException;
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2014 Sun Microsystems, Inc.
 */
package org.openide.io.base;

/**
 * Event fired when something happens to a line in the Output Window.
 *
 * @author Jaroslav Tulach, Petr Hamernik, Jaroslav Havlin
 */
public abstract class BaseOutputEvent extends java.util.EventObject {
    /** generated Serialized Version UID */
    static final long serialVersionUID = 4809584286971828815L;
    /** Create an event.
    * @param src the tab in question
    */
    public BaseOutputEvent (BaseInputOutput src) {
        super (src);
    }

    /** Get the text on the line.
    * @return the text
    */
    public abstract String getLine ();

    /** Get the Output Window tab in question.
    * @return the tab
    */
    public BaseInputOutput getInputOutput() {
        return (BaseInputOutput) getSource();
    }
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2014 Sun Microsystems, Inc.
 */
package org.openide.io.base;

/**
 * Listener to actions taken on a line in the Output Window.
 *
 * @author Jaroslav Tulach
 * @version 0.11 Dec 01, 1997
 */
public interface BaseOutputListener extends java.util.EventListener,
        BaseIOLinkInfo {

    /**
     * Called when some sort of action is performed on a line.
     *
     * @param ev the event describing the line
     */
    void outputLineAction(BaseOutputEvent ev);
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2014 Sun Microsystems, Inc.
 */
package org.openide.io.base;

import java.util.EventListener;
import java.util.Set;

/**
 * Base class for adding tagging information to output text.
 *
 * @author jhavlin
 */
public interface BaseOutputTag extends BaseIOLinkInfo, EventListener {

    /**
     * Get type of this tag.
     *
     * @return Type of the tag.
     */
    String getType();

    /**
     * Get value of an attribute specified by name.
     *
     * @param attributeName Name of the attribute.
     * @return Value of the attribute, or null if it is not available.
     * @throws IllegalArgumentException If tag of this type should not be
     * queried for attribute of name {@code  attributeName}.
     */
    Object getAttribute(String attributeName);

    /**
     * Get set of names of available attributes.
     *
     * @return Set of attribute names.
     */
    Set<String> getAttributeNames();
}

Line 0 Link Here

(-)a/openide.io.base/src/org/openide/io/base/Bundle.properties (+1 lines)
	1	OpenIDE-Module-Name=Base I/O APIs




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2014 Sun Microsystems, Inc.
 */
package org.openide.io.base;

/**
 * Helper class for finding extensions in I/O's lookup.
 *
 * @author jhavlin
 */
class ExtrasHelper {

    private ExtrasHelper() {}

    /**
     * Check whether class {@code extras} is present in the I/O's lookup.
     *
     * @param io I/O to check
     * @param extras Extension class that should be supported.
     *
     * @return True if the I/O supports the extension class, false otherwise.
     */
    static boolean isSupported(BaseInputOutput io, Class<?> extras) {
        Object o = io.getLookup().lookup(extras);
        return o != null;
    }

    /**
     * Get extension of given type, or throw an exception if it is not present.
     *
     * @param <T> Type of the extension.
     * @param io I/O to get the extension for.
     * @param cls Extension class.
     *
     * @return The extension object of given type.
     * @throws IllegalArgumentException If the I/O does not support this
     * extension type.
     */
    static <T> T getExtras(BaseInputOutput io, Class<T> cls) {
        T extras = io.getLookup().lookup(cls);
        if (extras == null) {
            throw new IllegalArgumentException("BaseInputOutput " + io
                    + " does not support " + cls);
        } else {
            return extras;
        }
    }

    /**
     * Get extension of given type, or return null if it is not present.
     *
     * @param <T> Type of the extension.
     * @param io I/O to get the extension for.
     * @param cls Extension class.
     *
     * @return The extension object of given type, or null if it is not
     * supported.
     */
    static <T> T find(BaseInputOutput io, Class<T> cls) {
        return io.getLookup().lookup(cls);
    }
}

Return to bug 245014

Lines 111-117 Link Here

(-)a/core.output2/nbproject/project.xml (-1 / +10 lines)
111	<build-prerequisite/>	111	<build-prerequisite/>
112	<compile-dependency/>	112	<compile-dependency/>
113	<run-dependency>	113	<run-dependency>
114	<specification-version>1.40</specification-version>	114	<specification-version>1.45</specification-version>
		115	</run-dependency>
		116	</dependency>
		117	<dependency>
		118	<code-name-base>org.openide.io.base</code-name-base>
		119	<build-prerequisite/>
		120	<compile-dependency/>
		121	<run-dependency>
		122	<release-version>1</release-version>
		123	<specification-version>1.0</specification-version>
115	</run-dependency>	124	</run-dependency>
116	</dependency>	125	</dependency>
117	<dependency>	126	<dependency>

Lines 40-80 Link Here

(-)a/openide.io/src/org/openide/windows/IOColors.java (-50 / +64 lines)
40	* Portions Copyrighted 2008 Sun Microsystems, Inc.	40	* Portions Copyrighted 2008 Sun Microsystems, Inc.
41	*/	41	*/
42		42
43	package org.openide.windows;	43	package org.openide.io.base;
44		44
45	import java.awt.Color;	45	import org.netbeans.api.annotations.common.CheckForNull;
		46	import org.netbeans.api.annotations.common.NonNull;
46	import org.openide.util.Lookup;	47	import org.openide.util.Lookup;
47		48
48	/**	49	/**
49	* Settings of colors for normal, error, hyperlink, important hyperlink lines.	50	* Settings of colors for normal, error, hyperlink, important hyperlink lines.
50	* Change is global for text past and future.	51	* Change is global for text past and future.
51	* <p>	52	* <p>
52	* Client usage:	53	* Client usage:
		54	* </p>
53	* <pre>	55	* <pre>
54	* // set important hyperlink color to red	56	// set important hyperlink color to red
55	* InputOutput io = ...;	57	BaseInputOutput io = ...;
56	* IOColors.setColor(io, IOColors.OutputType.HYPERLINK_IMPORTANT, Color.RED);	58	if (BaseIOColors.isSupported(io)) {
57	* </pre>	59	BaseIOColors.setColor(io, BaseIOColors.OutputType.HYPERLINK_IMPORTANT, Color.RED);
58	* How to support {@link IOColors} in own {@link IOProvider} implementation:	60	}
		61	</pre>
		62	* How to support {@link BaseIOColors} in own {@link BaseIOProvider} implementation:
59	* <ul>	63	* <ul>
60	* <li> {@link InputOutput} provided by {@link IOProvider} has to implement {@link org.openide.util.Lookup.Provider}	64	* <li> Implement some {@link Provider} of BaseIOColors.
61	* <li> Extend {@link IOColors} and implement its abstract methods	65	* <li> Place instance of {@link BaseIOColors} to {@link Lookup} provided by {@link BaseInputOutput}.
62	* <li> Place instance of {@link IOColors} to {@link Lookup} provided by {@link InputOutput}
63	* </ul>	66	* </ul>
64	* @see IOColorLines	67	* @see BaseIOColorLines
65	* @see IOColorPrint	68	* @see BaseIOColorPrint
66	* @since 1.16	69	* @author Tomas Holy, Jaroslav Havlin
67	* @author Tomas Holy
68	*/	70	*/
69	public abstract class IOColors {	71	public final class BaseIOColors {
70		72
71	private static IOColors find(InputOutput io) {	73	private BaseIOColors() {}
72	if (io instanceof Lookup.Provider) {
73	Lookup.Provider p = (Lookup.Provider) io;
74	return p.getLookup().lookup(IOColors.class);
75	}
76	return null;
77	}
78		74
79	/**	75	/**
80	* output types	76	* output types
Lines 110-158 Link Here
110	}	106	}
111		107
112	/**	108	/**
113	* Gets current color for output	109	* Gets current color for output.
114	* @param io InputOutput to operate on	110	* @param io {@link BaseInputOutput} to operate on.
115	* @param type output type to get color for	111	* @param type Output type to get color for.
116	* @return current color for specified output type or null if not supported	112	* @return Current color for specified output type or null if not supported.
117	*/	113	*/
118	public static Color getColor(InputOutput io, OutputType type) {	114	public static @CheckForNull BaseColor getColor(
119	IOColors ioc = find(io);	115	@NonNull BaseInputOutput io,
		116	@NonNull OutputType type) {
		117
		118	Provider ioc = ExtrasHelper.find(io, BaseIOColors.Provider.class);
120	return ioc != null ? ioc.getColor(type) : null;	119	return ioc != null ? ioc.getColor(type) : null;
121	}	120	}
122		121
123	/**	122	/**
124	* Sets specified color for output	123	* Sets specified color for output.
125	* @param io InputOutput to operate on	124	*
126	* @param type output type to set color for	125	* @param io {@link BaseInputOutput} to operate on.
127	* @param color new color for specified output type	126	* @param type Output type to set color for.
		127	* @param color New color for specified output type.
128	*/	128	*/
129	public static void setColor(InputOutput io, OutputType type, Color color) {	129	public static void setColor(
130	IOColors ioc = find(io);	130	@NonNull BaseInputOutput io,
		131	@NonNull OutputType type,
		132	@NonNull BaseColor color) {
		133	Provider ioc = ExtrasHelper.find(io, BaseIOColors.Provider.class);
131	if (ioc != null) {	134	if (ioc != null) {
132	ioc.setColor(type, color);	135	ioc.setColor(type, color);
133	}	136	}
134	}	137	}
135		138
136	/**	139	/**
137	* Checks whether this feature is supported for provided IO	140	* Checks whether this feature is supported for provided IO.
138	* @param io IO to check on	141	*
139	* @return true if supported	142	* @param io IO to check on.
		143	* @return True if supported.
140	*/	144	*/
141	public static boolean isSupported(InputOutput io) {	145	public static boolean isSupported(@NonNull BaseInputOutput io) {
142	return find(io) != null;	146	return ExtrasHelper.isSupported(io, BaseIOColors.Provider.class);
143	}	147	}
144		148
145	/**	149	/**
146	* Gets current color for output	150	* SPI for implementing support for output coloring.
147	* @param type output type to get color for	151	*
148	* @return current color for specified output	152	* @see BaseIOColors
149	*/	153	*/
150	abstract protected Color getColor(OutputType type);	154	public interface Provider {
151		155
152	/**	156	/**
153	* Sets specified color for output	157	* Gets current color for output.
154	* @param type output type to set color for	158	*
155	* @param color new color for specified output type	159	* @param type Output type to get color for.
156	*/	160	* @return Current color for specified output.
157	abstract protected void setColor(OutputType type, Color color);	161	*/
		162	@NonNull BaseColor getColor(@NonNull OutputType type);
		163
		164	/**
		165	* Sets specified color for output
		166	*
		167	* @param type Output type to set color for.
		168	* @param color New color for specified output type.
		169	*/
		170	void setColor(@NonNull OutputType type, @NonNull BaseColor color);
		171	}
158	}	172	}

Lines 53-70 Link Here

(-)a/core.output2/src/org/netbeans/core/output2/NbIO.java (-15 / +196 lines)
53	import java.awt.*;	53	import java.awt.*;
54	import java.io.IOException;	54	import java.io.IOException;
55	import java.io.Reader;	55	import java.io.Reader;
		56	import java.util.EnumSet;
56	import org.netbeans.core.output2.options.OutputOptions;	57	import org.netbeans.core.output2.options.OutputOptions;
		58	import org.openide.io.base.BaseColor;
		59	import org.openide.io.base.BaseIOColorLines;
		60	import org.openide.io.base.BaseIOColorPrint;
		61	import org.openide.io.base.BaseIOColors;
		62	import org.openide.io.base.BaseIOFolding;
		63	import org.openide.io.base.BaseIOHyperlink;
		64	import org.openide.io.base.BaseIOLinkInfo;
		65	import org.openide.io.base.BaseIOPosition;
		66	import org.openide.io.base.BaseIOSelect;
		67	import org.openide.io.base.BaseIOTab;
		68	import org.openide.io.base.BaseInputOutput;
		69	import org.openide.io.base.BaseOutputEvent;
		70	import org.openide.io.base.BaseOutputListener;
57	import org.openide.util.Exceptions;	71	import org.openide.util.Exceptions;
58	import org.openide.util.Lookup;	72	import org.openide.util.Lookup;
59	import org.openide.util.lookup.Lookups;	73	import org.openide.util.lookup.Lookups;
60	import org.openide.windows.IOColorLines;	74	import org.openide.windows.IOColorLines;
61	import org.openide.windows.IOColorPrint;	75	import org.openide.windows.IOColorPrint;
62	import org.openide.windows.IOColors;	76	import org.openide.windows.IOColors;
		77	import org.openide.windows.IOColors.OutputType;
63	import org.openide.windows.IOContainer;	78	import org.openide.windows.IOContainer;
64	import org.openide.windows.IOFolding;	79	import org.openide.windows.IOFolding;
65	import org.openide.windows.IOPosition;	80	import org.openide.windows.IOPosition;
66	import org.openide.windows.IOSelect;	81	import org.openide.windows.IOSelect;
		82	import org.openide.windows.IOSelect.AdditionalOperation;
67	import org.openide.windows.IOTab;	83	import org.openide.windows.IOTab;
		84	import org.openide.windows.OutputEvent;
68		85
69	/** Implementation of InputOutput. Implements calls as a set of	86	/** Implementation of InputOutput. Implements calls as a set of
70	* "commands" which are passed up to Dispatcher to be run on the event	87	* "commands" which are passed up to Dispatcher to be run on the event
Lines 72-78 Link Here
72	*	89	*
73	* @author Tim Boudreau	90	* @author Tim Boudreau
74	*/	91	*/
75	class NbIO implements InputOutput, Lookup.Provider {	92	class NbIO implements InputOutput, BaseInputOutput, Lookup.Provider {
76		93
77	private Boolean focusTaken = null;	94	private Boolean focusTaken = null;
78	private volatile boolean closed = false;	95	private volatile boolean closed = false;
Lines 263-268 Link Here
263	return actions;	280	return actions;
264	}	281	}
265		282
		283	@Override
266	public void reset() {	284	public void reset() {
267	if (Controller.LOG) Controller.log (this + ": reset");	285	if (Controller.LOG) Controller.log (this + ": reset");
268	closed = false;	286	closed = false;
Lines 327-333 Link Here
327	ioColors = new IOColorsImpl();	345	ioColors = new IOColorsImpl();
328	lookup = Lookups.fixed(ioTab, ioColors, new IOPositionImpl(),	346	lookup = Lookups.fixed(ioTab, ioColors, new IOPositionImpl(),
329	new IOColorLinesImpl(), new IOColorPrintImpl(),	347	new IOColorLinesImpl(), new IOColorPrintImpl(),
330	new IOSelectImpl(), new IOFoldingImpl(), options);	348	new IOSelectImpl(), new BaseIOSelectImpl(),
		349	new IOFoldingImpl(), new BaseIOHyperlinkImpl(), options);
331	}	350	}
332	return lookup;	351	return lookup;
333	}	352	}
Lines 485-491 Link Here
485	return ioColors != null ? ioColors.getColor(type) : AbstractLines.getDefColors()[type.ordinal()];	504	return ioColors != null ? ioColors.getColor(type) : AbstractLines.getDefColors()[type.ordinal()];
486	}	505	}
487		506
488	private class IOTabImpl extends IOTab {	507	private class IOTabImpl extends IOTab implements BaseIOTab.Provider {
489	Icon icon;	508	Icon icon;
490	String toolTip;	509	String toolTip;
491		510
Lines 495-501 Link Here
495	}	514	}
496		515
497	@Override	516	@Override
498	protected String getToolTipText() {	517	public String getToolTipText() {
499	return toolTip;	518	return toolTip;
500	}	519	}
501		520
Lines 506-521 Link Here
506	}	525	}
507		526
508	@Override	527	@Override
509	protected void setToolTipText(String text) {	528	public void setToolTipText(String text) {
510	toolTip = text;	529	toolTip = text;
511	post(NbIO.this, IOEvent.CMD_SET_TOOLTIP, toolTip);	530	post(NbIO.this, IOEvent.CMD_SET_TOOLTIP, toolTip);
512	}	531	}
513	}	532	}
514		533
515	private class IOPositionImpl extends IOPosition {	534	private class IOPositionImpl extends IOPosition
		535	implements BaseIOPosition.Provider {
516		536
517	@Override	537	@Override
518	protected Position currentPosition() {	538	public PositionImpl currentPosition() {
519	OutWriter out = out();	539	OutWriter out = out();
520	int size = 0;	540	int size = 0;
521	if (out != null) {	541	if (out != null) {
Lines 525-531 Link Here
525	}	545	}
526	}	546	}
527		547
528	private class PositionImpl implements IOPosition.Position {	548	private class PositionImpl implements IOPosition.Position,
		549	BaseIOPosition.Position {
529	private int pos;	550	private int pos;
530		551
531	public PositionImpl(int pos) {	552	public PositionImpl(int pos) {
Lines 537-543 Link Here
537	}	558	}
538	}	559	}
539		560
540	private class IOColorLinesImpl extends IOColorLines {	561	private class IOColorLinesImpl extends IOColorLines implements BaseIOColorLines.Provider {
541		562
542	@Override	563	@Override
543	protected void println(CharSequence text, OutputListener listener, boolean important, Color color) throws IOException {	564	protected void println(CharSequence text, OutputListener listener, boolean important, Color color) throws IOException {
Lines 546-554 Link Here
546	out.print(text, listener, important, color, null, OutputKind.OUT, true);	567	out.print(text, listener, important, color, null, OutputKind.OUT, true);
547	}	568	}
548	}	569	}
		570
		571	@Override
		572	public void println(CharSequence text, boolean important, BaseColor color,
		573	BaseIOLinkInfo... extendedInfo) throws IOException {
		574	OutWriter out = out();
		575	if (out != null) {
		576	OutputListener l = findAndConvertOutputListener(extendedInfo);
		577	out.print(text, l, important, convertToColor(color), null,
		578	OutputKind.OUT, true);
		579	}
		580	}
549	}	581	}
550		582
551	private class IOColorPrintImpl extends IOColorPrint {	583	private class IOColorPrintImpl extends IOColorPrint implements BaseIOColorPrint.Provider {
552		584
553	@Override	585	@Override
554	protected void print(CharSequence text, OutputListener listener, boolean important, Color color) throws IOException {	586	protected void print(CharSequence text, OutputListener listener, boolean important, Color color) throws IOException {
Lines 557-562 Link Here
557	out.print(text, listener, important, color, null, OutputKind.OUT, false);	589	out.print(text, listener, important, color, null, OutputKind.OUT, false);
558	}	590	}
559	}	591	}
		592
		593	@Override
		594	public void print(CharSequence text, boolean important, BaseColor color,
		595	BaseIOLinkInfo... extendedInfo) throws IOException {
		596	OutWriter out = out();
		597	if (out != null) {
		598	OutputListener l = findAndConvertOutputListener(extendedInfo);
		599	out.print(text, l, important, convertToColor(color), null,
		600	OutputKind.OUT, false);
		601	}
		602	}
560	}	603	}
561		604
562	private class IOSelectImpl extends IOSelect {	605	private class IOSelectImpl extends IOSelect {
Lines 568-574 Link Here
568	}	611	}
569	}	612	}
570		613
571	private class IOColorsImpl extends IOColors {	614	private class BaseIOSelectImpl implements BaseIOSelect.Provider {
		615
		616	@Override
		617	public void select(Set<BaseIOSelect.AdditionalOperation> extraOps) {
		618	if (Controller.LOG) {
		619	Controller.log(this + ": IOSelect.select"); //NOI18N
		620	}
		621	NbIO.post(NbIO.this, IOEvent.CMD_FINE_SELECT,
		622	convertIOSelectOps(extraOps));
		623	}
		624	}
		625
		626	private class IOColorsImpl extends IOColors implements BaseIOColors.Provider {
572	Color[] clrs = new Color[OutputType.values().length];	627	Color[] clrs = new Color[OutputType.values().length];
573		628
574	@Override	629	@Override
Lines 581-592 Link Here
581	clrs[type.ordinal()] = color;	636	clrs[type.ordinal()] = color;
582	post(NbIO.this, IOEvent.CMD_DEF_COLORS, type);	637	post(NbIO.this, IOEvent.CMD_DEF_COLORS, type);
583	}	638	}
		639
		640	@Override
		641	public BaseColor getColor(BaseIOColors.OutputType type) {
		642	return convertToBaseColor(getColor(convertOutputType(type)));
		643	};
		644
		645	@Override
		646	public void setColor(BaseIOColors.OutputType type, BaseColor color) {
		647	setColor(convertOutputType(type), convertToColor(color));
		648	}
584	}	649	}
585		650
586	private class IOFoldingImpl extends IOFolding {	651	private class IOFoldingImpl extends IOFolding implements BaseIOFolding.Provider {
587		652
588	@Override	653	@Override
589	protected FoldHandleDefinition startFold(boolean expanded) {	654	public NbIoFoldHandleDefinition startFold(boolean expanded) {
590	synchronized (outOrException()) {	655	synchronized (outOrException()) {
591	if (currentFold != null) {	656	if (currentFold != null) {
592	throw new IllegalStateException(	657	throw new IllegalStateException(
Lines 597-603 Link Here
597	}	662	}
598	}	663	}
599		664
600	class NbIoFoldHandleDefinition extends IOFolding.FoldHandleDefinition {	665	class NbIoFoldHandleDefinition extends IOFolding.FoldHandleDefinition
		666	implements BaseIOFolding.FoldHandleDefinition{
601		667
602	private final NbIoFoldHandleDefinition parent;	668	private final NbIoFoldHandleDefinition parent;
603	private final int start;	669	private final int start;
Lines 635-641 Link Here
635	}	701	}
636		702
637	@Override	703	@Override
638	public FoldHandleDefinition startFold(boolean expanded) {	704	public NbIoFoldHandleDefinition startFold(boolean expanded) {
639	synchronized (outOrException()) {	705	synchronized (outOrException()) {
640	if (end != -1) {	706	if (end != -1) {
641	throw new IllegalStateException(	707	throw new IllegalStateException(
Lines 689-694 Link Here
689	}	755	}
690	}	756	}
691		757
		758	private class BaseIOHyperlinkImpl implements BaseIOHyperlink.Provider {
		759
		760	@Override
		761	public boolean isSupported(Class<? extends BaseIOLinkInfo> cls) {
		762	return BaseOutputListener.class.isAssignableFrom(cls);
		763	}
		764
		765	@Override
		766	public void println(BaseIOHyperlink.Type type, String s,
		767	boolean important, BaseIOLinkInfo... linkInfo) throws IOException {
		768	OutputWriter writer = BaseIOHyperlink.Type.ERR.equals(type)
		769	? getErr() : getOut();
		770	if (writer != null) {
		771	OutputListener l = findAndConvertOutputListener(linkInfo);
		772	writer.println(s, l, important);
		773	}
		774	}
		775	}
		776
692	private int getLastLineNumber() {	777	private int getLastLineNumber() {
693	return Math.max(0, out().getLines().getLineCount() - 2);	778	return Math.max(0, out().getLines().getLineCount() - 2);
694	}	779	}
Lines 707-710 Link Here
707	OutputOptions getOptions() {	792	OutputOptions getOptions() {
708	return this.options;	793	return this.options;
709	}	794	}
		795
		796	/**
		797	* Find the first {@link BaseOutputListener} in the list of hyperlink
		798	* extension objects, convert it to {@link OutputListener} and return it.
		799	*/
		800	private OutputListener findAndConvertOutputListener(BaseIOLinkInfo... exts) {
		801	for (Object o : exts) {
		802	if (o instanceof BaseOutputListener) {
		803	return convertToOutputListener((BaseOutputListener) o);
		804	}
		805	}
		806	return null;
		807	}
		808
		809	private OutputListener convertToOutputListener(final BaseOutputListener l) {
		810	return new OutputListener() {
		811
		812	@Override
		813	public void outputLineSelected(OutputEvent ev) {
		814	}
		815
		816	@Override
		817	public void outputLineAction(OutputEvent ev) {
		818	l.outputLineAction(convertToOutputEventBase(ev));
		819	}
		820
		821	@Override
		822	public void outputLineCleared(OutputEvent ev) {
		823	}
		824	};
		825	}
		826
		827	private BaseOutputEvent convertToOutputEventBase(final OutputEvent e) {
		828	InputOutput origIO = e.getInputOutput();
		829	BaseInputOutput src = origIO instanceof BaseInputOutput
		830	? (BaseInputOutput) origIO : this;
		831	return new BaseOutputEvent(src) {
		832	@Override
		833	public String getLine() {
		834	return e.getLine();
		835	}
		836	};
		837	}
		838
		839	private Set<AdditionalOperation> convertIOSelectOps(
		840	Set<BaseIOSelect.AdditionalOperation> ops) {
		841	Set<AdditionalOperation> s = EnumSet.noneOf(AdditionalOperation.class);
		842	for (BaseIOSelect.AdditionalOperation bo : ops) {
		843	switch (bo) {
		844	case OPEN:
		845	s.add(AdditionalOperation.OPEN);
		846	break;
		847	case REQUEST_ACTIVE:
		848	s.add(AdditionalOperation.REQUEST_ACTIVE);
		849	break;
		850	case REQUEST_VISIBLE:
		851	s.add(AdditionalOperation.REQUEST_VISIBLE);
		852	break;
		853	}
		854	}
		855	return s;
		856	}
		857
		858	private OutputType convertOutputType(BaseIOColors.OutputType baseType) {
859	switch (baseType) {
860	case INPUT:
861	return OutputType.INPUT;
862	case OUTPUT:
863	return OutputType.OUTPUT;
864	case ERROR:
865	return OutputType.ERROR;
866	case HYPERLINK:
867	return OutputType.HYPERLINK;
868	case HYPERLINK_IMPORTANT:
869	return OutputType.HYPERLINK_IMPORTANT;
870	case LOG_DEBUG:
871	return OutputType.LOG_DEBUG;
872	case LOG_SUCCESS:
873	return OutputType.LOG_SUCCESS;
874	case LOG_WARNING:
875	return OutputType.LOG_WARNING;
876	case LOG_FAILURE:
877	return OutputType.LOG_FAILURE;
878	default:
879	throw new IllegalArgumentException(
880	"Unknown output type " + baseType); //NOI18N
881	}
882	}
883
884	private Color convertToColor(BaseColor baseColor) {
885	return new Color(baseColor.getRGB(), true);
886	}
887
888	private BaseColor convertToBaseColor(Color color) {
889	return new BaseColor(color.getRGB(), true);
890	}
710	}	891	}

Lines 45-51 Link Here

(-)a/core.output2/src/org/netbeans/core/output2/NbIOProvider.java (-51 / +17 lines)
45	package org.netbeans.core.output2;	45	package org.netbeans.core.output2;
46		46
47	import java.io.IOException;	47	import java.io.IOException;
48	import java.util.WeakHashMap;
49	import javax.swing.Action;	48	import javax.swing.Action;
50	import org.openide.util.Exceptions;	49	import org.openide.util.Exceptions;
51	import org.openide.util.NbBundle;	50	import org.openide.util.NbBundle;
Lines 55-73 Link Here
55	import org.openide.windows.OutputWriter;	54	import org.openide.windows.OutputWriter;
56		55
57	/**	56	/**
58	* Supplies Output Window implementation through Lookup.	57	* Supplies Output Window implementation through Lookup. Provider of I/O
		58	* instances for the org.openide.io (package org.openide.windows) API.
		59	*
59	* @author Jesse Glick, Tim Boudreau	60	* @author Jesse Glick, Tim Boudreau
60	*/	61	*/
61	@org.openide.util.lookup.ServiceProvider(service=org.openide.windows.IOProvider.class, position=100)	62	@org.openide.util.lookup.ServiceProvider(service=org.openide.windows.IOProvider.class, position=100)
62	public final class NbIOProvider extends IOProvider {	63	public final class NbIOProvider extends IOProvider {
63	private static final WeakHashMap<IOContainer, PairMap> containerPairMaps =
64	new WeakHashMap<IOContainer, PairMap>();
65		64
66	private static final String STDOUT = NbBundle.getMessage(NbIOProvider.class,	65	private static final String STDOUT = NbBundle.getMessage(NbIOProvider.class,
67	"LBL_STDOUT"); //NOI18N	66	"LBL_STDOUT"); //NOI18N
68		67
69	private static final String NAME = "output2"; // NOI18N	68	@Override
70		69	public String getName() {
		70	return SharedProvider.getInstance().getName();
		71	}
		72
		73	@Override
71	public OutputWriter getStdOut() {	74	public OutputWriter getStdOut() {
72	if (Controller.LOG) {	75	if (Controller.LOG) {
73	Controller.log("NbIOProvider.getStdOut");	76	Controller.log("NbIOProvider.getStdOut");
Lines 93-98 Link Here
93	}	96	}
94		97
95		98
		99	@Override
96	public InputOutput getIO(String name, boolean newIO) {	100	public InputOutput getIO(String name, boolean newIO) {
97	return getIO (name, newIO, new Action[0], null);	101	return getIO (name, newIO, new Action[0], null);
98	}	102	}
Lines 108-160 Link Here
108	}	112	}
109		113
110	@Override	114	@Override
111	public String getName() {	115	public InputOutput getIO(String name, boolean newIO, Action[] actions,
112	return NAME;	116	IOContainer ioContainer) {
		117
		118	return SharedProvider.getInstance().getIO(name, newIO, actions,
		119	ioContainer);
113	}	120	}
114		121
115	@Override	122	static void dispose(NbIO io) {
116	public InputOutput getIO(String name, boolean newIO,	123	SharedProvider.dispose(io);
117	Action[] toolbarActions, IOContainer ioContainer) {
118	if (Controller.LOG) {
119	Controller.log("GETIO: " + name + " new:" + newIO);
120	}
121	IOContainer realIoContainer = ioContainer == null
122	? IOContainer.getDefault() : ioContainer;
123	NbIO result;
124	synchronized (containerPairMaps) {
125	PairMap namesToIos = containerPairMaps.get(realIoContainer);
126	result = namesToIos != null ? namesToIos.get(name) : null;
127	}
128	if (result == null \|\| newIO) {
129	result = new NbIO(name, toolbarActions, realIoContainer);
130	synchronized (containerPairMaps) {
131	PairMap namesToIos = containerPairMaps.get(realIoContainer);
132	if (namesToIos == null) {
133	namesToIos = new PairMap();
134	containerPairMaps.put(realIoContainer, namesToIos);
135	}
136	namesToIos.add(name, result);
137	}
138	NbIO.post(new IOEvent(result, IOEvent.CMD_CREATE, newIO));
139	}
140	return result;
141	}
142
143
144	static void dispose (NbIO io) {
145	IOContainer ioContainer = io.getIOContainer();
146	if (ioContainer == null) {
147	ioContainer = IOContainer.getDefault();
148	}
149	synchronized (containerPairMaps) {
150	PairMap namesToIos = containerPairMaps.get(ioContainer);
151	if (namesToIos != null) {
152	namesToIos.remove(io);
153	if (namesToIos.isEmpty()) {
154	containerPairMaps.remove(ioContainer);
155	}
156	}
157	}
158	}	124	}
159	}	125	}
160		126

Line 0 Link Here

(-)a/core.output2/src/org/netbeans/core/output2/NbIOProviderBase.java (+103 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2014 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2014 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.core.output2;
		43
		44	import java.util.EventListener;
		45	import java.util.logging.Level;
		46	import java.util.logging.Logger;
		47	import javax.swing.Action;
		48	import org.openide.io.base.BaseIOProvider;
		49	import org.openide.io.base.BaseInputOutput;
		50	import org.openide.util.Lookup;
		51	import org.openide.util.lookup.ServiceProvider;
		52
		53	/**
		54	* Provider of I/O instances for the org.openide.io.base API.
		55	*
		56	* @author jhavlin
		57	*/
		58	@ServiceProvider(service = BaseIOProvider.class, position = 100)
		59	public class NbIOProviderBase extends BaseIOProvider {
		60
		61	private static final Logger LOG = Logger.getLogger(
		62	NbIOProviderBase.class.getName());
		63
		64	@Override
65	public String getName() {
66	return SharedProvider.getInstance().getName();
67	}
68
69	@Override
70	public BaseInputOutput getIO(String name, boolean newIO,
71	Lookup context, EventListener... actions) {
72
73	Action[] actionArray = convertActions(actions);
74	return SharedProvider.getInstance().getIO(name, newIO, actionArray,
75	null);
76	}
77
78	private Action[] convertActions(EventListener[] actions) {
79	Action[] actionArray = new Action[actions.length];
80	for (int i = 0; i < actions.length; i++) {
81	if (actions[i] instanceof Action) {
82	actionArray[i] = (Action) actions[i];
83	} else if (actions[i] == null) {
84	LOG.log(Level.WARNING, "Null action", //NOI18N
85	new IllegalArgumentException());
86	return new Action[0];
87	} else {
88	LOG.log(Level.WARNING, "Only actions of type javax." //NOI18N
89	+ "swing.Action are supported, but object of " //NOI18N
90	+ "type " + actions[i].getClass() + " found", //NOI18N
91	new IllegalArgumentException());
92	return new Action[0];
93	}
94	}
95	return actionArray;
96	}
97
98	@Override
99	public boolean isActionTypeSupported(
100	Class<? extends EventListener> cls) {
101	return Action.class.isAssignableFrom(cls);
102	}
103	}

Line 0 Link Here

(-)a/openide.io.base/apichanges.xml (+139 lines)
		1	<?xml version="1.0" encoding="UTF-8"?>
		2	<!--
		3	DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		4
		5	Copyright 2014 Oracle and/or its affiliates. All rights reserved.
		6
		7	Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		8	Other names may be trademarks of their respective owners.
		9
		10	The contents of this file are subject to the terms of either the GNU
		11	General Public License Version 2 only ("GPL") or the Common
		12	Development and Distribution License("CDDL") (collectively, the
		13	"License"). You may not use this file except in compliance with the
		14	License. You can obtain a copy of the License at
		15	http://www.netbeans.org/cddl-gplv2.html
		16	or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		17	specific language governing permissions and limitations under the
		18	License. When distributing the software, include this License Header
		19	Notice in each file and include the License file at
		20	nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		21	particular file as subject to the "Classpath" exception as provided
		22	by Oracle in the GPL Version 2 section of the License file that
		23	accompanied this code. If applicable, add the following below the
		24	License Header, with the fields enclosed by brackets [] replaced by
		25	your own identifying information:
		26	"Portions Copyrighted [year] [name of copyright owner]"
		27
		28	If you wish your version of this file to be governed by only the CDDL
		29	or only the GPL Version 2, indicate your decision by adding
		30	"[Contributor] elects to include this software in this distribution
		31	under the [CDDL or GPL Version 2] license." If you do not indicate a
		32	single choice of license, a recipient has the option to distribute
		33	your version of this file under either the CDDL, the GPL Version 2 or
		34	to extend the choice of license to its licensees as provided above.
		35	However, if you add GPL Version 2 code and therefore, elected the GPL
		36	Version 2 license, then the option applies only if the new code is
		37	made subject to such option by the copyright holder.
		38
		39	Contributor(s):
		40
		41	Portions Copyrighted 2014 Sun Microsystems, Inc.
		42	-->
		43
		44	<?xml-stylesheet type="text/xml" href="../nbbuild/javadoctools/apichanges.xsl"?>
		45	<!DOCTYPE apichanges PUBLIC "-//NetBeans//DTD API changes list 1.0//EN" "../nbbuild/javadoctools/apichanges.dtd">
		46
		47	<!--
		48
		49	INFO FOR PEOPLE ADDING CHANGES:
		50
		51	Check the DTD (apichanges.dtd) for details on the syntax. You do not
		52	need to regenerate the HTML, as this is part of Javadoc generation; just
		53	change the XML. Rough syntax of a change (several parts optional):
		54
		55	<change>
		56	<api name="compiler"/>
		57	<summary>Some brief description here, can use <b>XHTML</b></summary>
		58	<version major="1" minor="99"/>
		59	<date day="13" month="6" year="2001"/>
		60	<author login="jrhacker"/>
		61	<compatibility addition="yes"/>
		62	<description>
		63	The main description of the change here.
		64	Again can use full <b>XHTML</b> as needed.
65	</description>
66	<class package="org.openide.compiler" name="DoWhatIWantCompiler"/>
67	<issue number="14309"/>
68	</change>
69
70	Also permitted elements: <package>, <branch>. <version> is API spec
71	version, recommended for all new changes. <compatibility> should say
72	if things were added/modified/deprecated/etc. and give all information
73	related to upgrading old code. List affected top-level classes and
74	link to issue numbers if applicable. See the DTD for more details.
75
76	Changes need not be in any particular order, they are sorted in various
77	ways by the stylesheet anyway.
78
79	Dates are assumed to mean "on the trunk". If you also make the same
80	change on a stabilization branch, use the <branch> tag to indicate this
81	and explain why the change was made on a branch in the <description>.
82
83	Please only change this file on the trunk! Rather: you can change it
84	on branches if you want, but these changes will be ignored; only the
85	trunk version of this file is important.
86
87	Deprecations do not count as incompatible, assuming that code using the
88	deprecated calls continues to see their documented behavior. But do
89	specify deprecation="yes" in <compatibility>.
90
91	This file is not a replacement for Javadoc: it is intended to list changes,
92	not describe the complete current behavior, for which ordinary documentation
93	is the proper place.
94
95	-->
96
97	<apichanges>
98
99	<!-- First, a list of API names you may use: -->
100	<apidefs>
101	<apidef name="io.base">Base I/O APIs</apidef>
102	<!-- etc. -->
103	</apidefs>
104
105	<!-- ACTUAL CHANGES BEGIN HERE: -->
106
107	<changes>
108
109	<!-- Start here... -->
110
111	</changes>
112
113	<!-- Now the surrounding HTML text and document structure: -->
114
115	<htmlcontents>
116	<!-- Generated from apichanges.xml -->
117	<head>
118	<title>Change History for the Base I/O APIs</title>
119	<link rel="stylesheet" href="prose.css" type="text/css"/>
120	</head>
121	<body>
122
123	<p class="overviewlink"><a href="@TOP@/overview-summary.html">Overview</a></p>
124
125	<h1>Introduction</h1>
126
127	<p>This document lists changes made to the <a href="@TOP@/overview-summary.html">Base I/O APIs</a>.</p>
128
129	<!-- The actual lists of changes, as summaries and details: -->
130	<hr/>
131	<standard-changelists module-code-name="org.openide.io.base/1"/>
132
133	<hr/><p>@FOOTER@</p>
134
135	</body>
136	</htmlcontents>
137
138	</apichanges>
139

Line 0 Link Here

(-)a/openide.io.base/nbproject/project.xml (+39 lines)
	1	<?xml version="1.0" encoding="UTF-8"?>
	2	<project xmlns="http://www.netbeans.org/ns/project/1">
	3	<type>org.netbeans.modules.apisupport.project</type>
	4	<configuration>
	5	<data xmlns="http://www.netbeans.org/ns/nb-module-project/3">
	6	<code-name-base>org.openide.io.base</code-name-base>
	7	<module-dependencies>
	8	<dependency>
	9	<code-name-base>org.netbeans.api.annotations.common</code-name-base>
	10	<build-prerequisite/>
	11	<compile-dependency/>
	12	<run-dependency>
	13	<release-version>1</release-version>
	14	<specification-version>1.24</specification-version>
	15	</run-dependency>
	16	</dependency>
	17	<dependency>
	18	<code-name-base>org.openide.util.base</code-name-base>
	19	<build-prerequisite/>
	20	<compile-dependency/>
	21	<run-dependency>
	22	<specification-version>9.1</specification-version>
	23	</run-dependency>
	24	</dependency>
	25	<dependency>
	26	<code-name-base>org.openide.util.lookup</code-name-base>
	27	<build-prerequisite/>
	28	<compile-dependency/>
	29	<run-dependency>
	30	<specification-version>8.25</specification-version>
	31	</run-dependency>
	32	</dependency>
	33	</module-dependencies>
	34	<public-packages>
	35	<package>org.openide.io.base</package>
	36	</public-packages>
	37	</data>
	38	</configuration>
	39	</project>

Lines 40-67 Link Here

(-)a/openide.io/src/org/openide/windows/FoldHandle.java (-22 / +11 lines)
40	* Portions Copyrighted 2013 Sun Microsystems, Inc.	40	* Portions Copyrighted 2013 Sun Microsystems, Inc.
41	*/	41	*/
42		42
43	package org.openide.windows;	43	package org.openide.io.base;
44		44
45	import java.util.logging.Level;	45	import java.util.logging.Level;
46	import java.util.logging.Logger;	46	import java.util.logging.Logger;
47	import org.netbeans.api.annotations.common.CheckForNull;	47	import org.netbeans.api.annotations.common.CheckForNull;
48	import org.openide.windows.IOFolding.FoldHandleDefinition;	48	import org.openide.io.base.BaseIOFolding.FoldHandleDefinition;
49		49
50	/**	50	/**
51	* An object that refers to a fold in output window. It can be used to finish	51	* An object that refers to a fold in output window. It can be used to finish
52	* the fold, or to create nested folds.	52	* the fold, or to create nested folds.
53	*	53	*
54	* @author jhavlin	54	* @author jhavlin
55	* @since openide.io/1.38
56	*/	55	*/
57	public final class FoldHandle {	56	public final class BaseFoldHandle {
58		57
59	private final FoldHandleDefinition definition;	58	private final FoldHandleDefinition definition;
60	private static final Logger LOG = Logger.getLogger(FoldHandle.class.getName());	59	private static final Logger LOG = Logger.getLogger(BaseFoldHandle.class.getName());
61	private FoldHandle currentChild;	60	private BaseFoldHandle currentChild;
62	private boolean finished = false;	61	private boolean finished = false;
63		62
64	FoldHandle(FoldHandleDefinition definition) {	63	BaseFoldHandle(FoldHandleDefinition definition) {
65	this.definition = definition;	64	this.definition = definition;
66	}	65	}
67		66
Lines 85-92 Link Here
85	* @throws IllegalStateException if the fold has been already finished, or	84	* @throws IllegalStateException if the fold has been already finished, or
86	* if an unfinished nested fold exists.	85	* if an unfinished nested fold exists.
87	*/	86	*/
88	public FoldHandle startFold(boolean expanded) {	87	public BaseFoldHandle startFold(boolean expanded) {
89	currentChild = new FoldHandle(definition.startFold(expanded));	88	currentChild = new BaseFoldHandle(definition.startFold(expanded));
90	return currentChild;	89	return currentChild;
91	}	90	}
92		91
Lines 106-113 Link Here
106	*	105	*
107	* @return True if {@link #finish()} or {@link #silentFinish()} has been	106	* @return True if {@link #finish()} or {@link #silentFinish()} has been
108	* already called on this fold handle, false otherwise.	107	* already called on this fold handle, false otherwise.
109	*
110	* @since openide.io/1.42
111	*/	108	*/
112	public boolean isFinished() {	109	public boolean isFinished() {
113	return finished;	110	return finished;
Lines 119-128 Link Here
119	* unfinished.	116	* unfinished.
120	*	117	*
121	* @return The last started nested fold. Can be null.	118	* @return The last started nested fold. Can be null.
122	*
123	* @since openide.io/1.42
124	*/	119	*/
125	public @CheckForNull FoldHandle getLastNestedFold() {	120	public @CheckForNull BaseFoldHandle getLastNestedFold() {
126	return currentChild;	121	return currentChild;
127	}	122	}
128		123
Lines 131-140 Link Here
131	* returns null if the last nested fold has been already finished.	126	* returns null if the last nested fold has been already finished.
132	*	127	*
133	* @return The last unfinished nested fold or null.	128	* @return The last unfinished nested fold or null.
134	*
135	* @since openide.io/1.42
136	*/	129	*/
137	public @CheckForNull FoldHandle getCurrentNestedFold() {	130	public @CheckForNull BaseFoldHandle getCurrentNestedFold() {
138	return (currentChild != null && !currentChild.isFinished())	131	return (currentChild != null && !currentChild.isFinished())
139	? currentChild	132	? currentChild
140	: null;	133	: null;
Lines 145-152 Link Here
145	* handle has been already finished. If an unfinished child fold exists, it	138	* handle has been already finished. If an unfinished child fold exists, it
146	* will be finished too. Any exception that could happen will be caught and	139	* will be finished too. Any exception that could happen will be caught and
147	* logged.	140	* logged.
148	*
149	* @since openide.io/1.42
150	*/	141	*/
151	public void silentFinish() {	142	public void silentFinish() {
152	if (!finished) {	143	if (!finished) {
Lines 170-179 Link Here
170	* @param expanded True to expand the new fold, false to collapse it, parent	161	* @param expanded True to expand the new fold, false to collapse it, parent
171	* folds will not be collapsed/expanded.	162	* folds will not be collapsed/expanded.
172	* @return The new fold handle, or null if it cannot be created.	163	* @return The new fold handle, or null if it cannot be created.
173	*
174	* @since openide.io/1.42
175	*/	164	*/
176	public @CheckForNull FoldHandle silentStartFold(boolean expanded) {	165	public @CheckForNull BaseFoldHandle silentStartFold(boolean expanded) {
177	if (!finished) {	166	if (!finished) {
178	if (currentChild != null && !currentChild.finished) {	167	if (currentChild != null && !currentChild.finished) {
179	currentChild.silentFinish();	168	currentChild.silentFinish();

Lines 40-112 Link Here

(-)a/openide.io/src/org/openide/windows/IOColorPrint.java (-55 / +76 lines)
40	* Portions Copyrighted 2009 Sun Microsystems, Inc.	40	* Portions Copyrighted 2009 Sun Microsystems, Inc.
41	*/	41	*/
42		42
43	package org.openide.windows;	43	package org.openide.io.base;
44		44
45	import java.awt.Color;
46	import java.io.IOException;	45	import java.io.IOException;
		46	import org.netbeans.api.annotations.common.NonNull;
		47	import org.netbeans.api.annotations.common.NullAllowed;
47	import org.openide.util.Lookup;	48	import org.openide.util.Lookup;
48		49
49	/**	50	/**
50	* Text printing with custom color.	51	* Text printing with custom color.
51	* <p>	52	* <p>
52	* Client usage:	53	* Client usage:
		54	* </p>
53	* <pre>	55	* <pre>
54	* InputOutput io = ...;	56	BaseInputOutput io = ...;
55	* OutputListener l = ...;	57	BaseOutputListener l = ...;
56	* OutputListener l2 = ...;	58	BaseOutputListener l2 = ...;
57	* IOColorPrint.print(io, "Green text", Color.GREEN);	59	if (BaseIOColorPrint.isSupported(io)) {
58	* IOColorPrint.print(io, " orange hyperlink ", l, false, Color.ORANGE);	60	BaseIOColorPrint.print(io, "Green text", Color.GREEN);
59	* IOColorPrint.print(io, " green hyperlink\n", l2, false, Color.GREEN);	61	BaseIOColorPrint.print(io, " orange hyperlink ", false, Color.ORANGE, l);
60	* </pre>	62	BaseIOColorPrint.print(io, " green hyperlink\n", false, Color.GREEN, l2);
61	* How to support {@link IOColorPrint} in own {@link IOProvider} implementation:	63	}
		64	</pre>
		65	* How to support {@link BaseIOColorPrint} in own {@link BaseIOProvider} implementation:
62	* <ul>	66	* <ul>
63	* <li> {@link InputOutput} provided by {@link IOProvider} has to implement {@link org.openide.util.Lookup.Provider}	67	* <li> Implement some {@link Provider} of BaseIOColorPrint.</li>
64	* <li> Extend {@link IOColorPrint} and implement its abstract methods	68	* <li> Place instance of {@link Provider} to {@link Lookup} provided by {@link BaseInputOutput}.</li>
65	* <li> Place instance of {@link IOColorPrint} to {@link Lookup} provided by {@link InputOutput}
66	* </ul>	69	* </ul>
67	* @see IOColors	70	* @see BaseIOColors
68	* @see IOColorLines	71	* @see BaseIOColorLines
69	* @since 1.18	72	* @author Tomas Holy, Jaroslav Havlin
70	* @author Tomas Holy
71	*/	73	*/
72	public abstract class IOColorPrint {	74	public final class BaseIOColorPrint {
73		75
74	private static IOColorPrint find(InputOutput io) {	76	private BaseIOColorPrint() {}
75	if (io instanceof Lookup.Provider) {
76	Lookup.Provider p = (Lookup.Provider) io;
77	return p.getLookup().lookup(IOColorPrint.class);
78	}
79	return null;
80	}
81		77
82	/**	78	/**
83	* Prints text with selected color	79	* Prints text with selected color
84	* @param io IO to print to	80	* @param io IO to print to.
85	* @param text a string to print to the tab	81	* @param text A string to print to the tab.
86	* @param color a color for the text (null allowed). If null is passed default color (see {@link IOColors}) is used.	82	* @param color A color for the text (null allowed). If null is passed
		83	* default color (see {@link BaseIOColors}) is used.
		84	* @throws java.io.IOException if printint to the output fails.
		85	* @throws IllegalArgumentException if the I/O does not support this
		86	* feature.
87	*/	87	*/
88	public static void print(InputOutput io, CharSequence text, Color color) throws IOException {	88	public static void print(
89	IOColorPrint iocl = find(io);	89	@NonNull BaseInputOutput io,
90	if (iocl != null) {	90	@NonNull CharSequence text,
91	iocl.print(text, null, false, color);	91	@NullAllowed BaseColor color) throws IOException {
92	}	92	print(io, text, false, color);
93	}	93	}
94		94
95	/**	95	/**
96	* Prints text with selected color and add listener for it	96	* Prints text with selected color and add listener for it
97	* @param io IO to print to	97	* @param io IO to print to.
98	* @param text a string to print to the tab	98	* @param text A string to print to the tab.
99	* @param listener a listener that will receive events about this text (null allowed)	99	* @param important Mark the line as important.
100	* @param important important mark the line as important.
101	* Makes the UI respond appropriately, eg. stop the automatic scrolling	100	* Makes the UI respond appropriately, eg. stop the automatic scrolling
102	* or highlight the hyperlink.	101	* or highlight the hyperlink.
103	* @param color a color for the text (null allowed). If null is passed default color (see {@link IOColors}) is used.	102	* @param color A color for the text (null allowed). If null is passed
		103	* default color (see {@link BaseIOColors}) is used.
		104	* @param extendedInfo Output listeners, output tags or similar objects, see
		105	* {@link BaseIOHyperlink}.
		106	* @throws java.io.IOException if writing to the output fails.
		107	* @throws IllegalArgumentException if the I/O does not support this
		108	* feature.
104	*/	109	*/
105	public static void print(InputOutput io, CharSequence text, OutputListener listener, boolean important, Color color) throws IOException {	110	public static void print(
106	IOColorPrint iocl = find(io);	111	@NonNull BaseInputOutput io,
107	if (iocl != null) {	112	@NonNull CharSequence text,
108	iocl.print(text, listener, important, color);	113	boolean important,
109	}	114	@NullAllowed BaseColor color,
		115	@NonNull BaseIOLinkInfo... extendedInfo)
		116	throws IOException {
		117
		118	ExtrasHelper.getExtras(io, BaseIOColorPrint.Provider.class).print(
		119	text, important, color, extendedInfo);
110	}	120	}
111		121
112		122
Lines 115-132 Link Here
115	* @param io IO to check on	125	* @param io IO to check on
116	* @return true if supported	126	* @return true if supported
117	*/	127	*/
118	public static boolean isSupported(InputOutput io) {	128	public static boolean isSupported(@NonNull BaseInputOutput io) {
119	return find(io) != null;	129	return ExtrasHelper.isSupported(io, BaseIOColorPrint.Provider.class);
120	}	130	}
121		131
122	/**	132	public interface Provider {
123	* Prints text with selected color and optionaly add listener for it	133
124	* @param text a string to print to the tab	134	/**
125	* @param listener a listener that will receive events about this text (null allowed)	135	* Prints text with selected color and optionaly add listener for it
126	* @param important important mark the line as important.	136	*
127	* Makes the UI respond appropriately, eg. stop the automatic scrolling	137	* @param text A string to print to the tab.
128	* or highlight the hyperlink.	138	* @param important Mark the line as important. Makes the UI
129	* @param color a color for the text (null allowed). If null is passed default color (see {@link IOColors}) is used.	139	* respond appropriately, eg. stop the automatic scrolling or highlight
130	*/	140	* the hyperlink.
131	abstract protected void print(CharSequence text, OutputListener listener, boolean important, Color color) throws IOException;	141	* @param color A color for the text (null allowed). If null is passed
		142	* default color (see {@link BaseIOColors}) is used.
		143	* @param extendedInfo Output listener, output tag or similar objects,
		144	* see {@link BaseIOHyperlink}.
		145	* @throws java.io.IOException if writing to the output fails.
		146	*/
		147	void print(
		148	@NonNull CharSequence text,
		149	boolean important,
		150	@NullAllowed BaseColor color,
		151	@NonNull BaseIOLinkInfo... extendedInfo) throws IOException;
		152	}
132	}	153	}

Lines 40-113 Link Here

(-)a/openide.io/src/org/openide/windows/IOSelect.java (-42 / +42 lines)
40	* Portions Copyrighted 2010 Sun Microsystems, Inc.	40	* Portions Copyrighted 2010 Sun Microsystems, Inc.
41	*/	41	*/
42		42
43	package org.openide.windows;	43	package org.openide.io.base;
44		44
45	import java.util.Set;	45	import java.util.Set;
46	import org.openide.util.Lookup;	46	import org.netbeans.api.annotations.common.NonNull;
47	import org.openide.util.Parameters;	47	import org.openide.util.Parameters;
48		48
49	/**	49	/**
50	* Capability of an InputOutput of finer grained selection of a component.	50	* Capability of an {@link BaseInputOutput} of fine grained selection of a
51	* <p>	51	* component.
52	* InputOutput.select() does too much.	52	*
53	* @author ivan	53	* @author ivan, Jaroslav Havlin
54	* @since 1.23
55	*/	54	*/
56	public abstract class IOSelect {	55	public final class BaseIOSelect {
		56
		57	private BaseIOSelect() {}
57		58
58	/**	59	/**
59	* Additional operations to perform when issuing {@link IOSelect#select}.	60	* Additional operations to perform when selecting the output tab.
60	* @author ivan	61	* @author ivan
61	*/	62	*/
62	public static enum AdditionalOperation {	63	public static enum AdditionalOperation {
63	/**	64	/**
64	* Additionally issue open() on the TopComponent containing the InputOutput.	65	* Additionally issue open() on the TopComponent containing the
65	*/	66	* {@link BaseInputOutput}.
		67	*/
66	OPEN,	68	OPEN,
67		69
68	/**	70	/**
69	* Additionally issue requestVisible() on the TopComponent containing the InputOutput.	71	* Additionally issue requestVisible() on the TopComponent containing
		72	* the {@link BaseInputOutput}.
70	*/	73	*/
71	REQUEST_VISIBLE,	74	REQUEST_VISIBLE,
72		75
73	/**	76	/**
74	* Additionally issue requestActive() on the TopComponent containing the InputOutput.	77	* Additionally issue requestActive() on the TopComponent containing
		78	* the {@link BaseInputOutput}.
75	*/	79	*/
76	REQUEST_ACTIVE	80	REQUEST_ACTIVE
77	}	81	}
78		82
79	private static IOSelect find(InputOutput io) {
80	if (io instanceof Lookup.Provider) {
81	Lookup.Provider p = (Lookup.Provider) io;
82	return p.getLookup().lookup(IOSelect.class);
83	}
84	return null;
85	}
86
87	/**	83	/**
88	* With an empty 'extraOps' simply selects this io	84	* With an empty 'extraOps' simply selects this io
89	* without involving it's containing TopComponent.	85	* without involving it's containing TopComponent.
90	* <p>	86	* <p>
91	* For example:	87	* For example:
		88	* </p>
92	* <pre>	89	* <pre>
93	* if (IOSelect.isSupported(io) {	90	* if (BaseIOSelect.isSupported(io) {
94	* IOSelect.select(io, EnumSet.noneOf(IOSelect.AdditionalOperation.class));	91	* BaseIOSelect.select(io, EnumSet.noneOf(IOSelect.AdditionalOperation.class));
95	* }	92	* }
96	* </pre>	93	* </pre>
97	* <p>	94	* <p>
98	* If this capability is not supported then regular InputOutput.select()	95	* If this capability is not supported then no operation will be performed.
99	* will be called.	96	* </p>
100	* @param io InputOutput to operate on.	97	* @param io {@link BaseInputOutput} to operate on.
101	* @param extraOps Additional operations to apply to the containing	98	* @param extraOps Additional operations to apply to the containing
102	* TopComponent.	99	* TopComponent.
103	*/	100	*/
104	public static void select(InputOutput io, Set<AdditionalOperation> extraOps) {	101	public static void select(BaseInputOutput io, Set<AdditionalOperation> extraOps) {
105	Parameters.notNull("extraOps", extraOps); // NOI18N	102	Parameters.notNull("extraOps", extraOps); // NOI18N
106	IOSelect ios = find(io);	103	Provider ios = ExtrasHelper.find(io, Provider.class);
107	if (ios != null)	104	if (ios != null) {
108	ios.select(extraOps);	105	ios.select(extraOps);
109	else	106	}
110	io.select(); // fallback
111	}	107	}
112		108
113	/**	109	/**
Lines 115-129 Link Here
115	* @param io IO to check on	111	* @param io IO to check on
116	* @return true if supported	112	* @return true if supported
117	*/	113	*/
118	public static boolean isSupported(InputOutput io) {	114	public static boolean isSupported(BaseInputOutput io) {
119	return find(io) != null;	115	return ExtrasHelper.isSupported(io, Provider.class);
120	}	116	}
121		117
122	/**	118	public interface Provider {
123	* With an empty 'extraOps' simply selects this io	119
124	* without involving it's containing TopComponent.	120	/**
125	* @param extraOps Additional operations to apply to the containing	121	* With an empty 'extraOps' simply selects this io without involving
126	* TopComponent.	122	* it's containing TopComponent.
127	*/	123	*
128	abstract protected void select(Set<AdditionalOperation> extraOps);	124	* @param extraOps Additional operations to apply to the containing
		125	* TopComponent.
		126	*/
		127	void select(@NonNull Set<AdditionalOperation> extraOps);
		128	}
129	}	129	}