<HTML>

    <HEAD>
        <TITLE>NetBeans Sources - Mercurial Overview</TITLE>
        <META NAME="description" CONTENT="Overview of Accessing NetBeans Sources via Mercurial">
        <META NAME="NAV_LINK" content="Mercurial">
        <link rel="stylesheet" type="text/css" HREF="../../netbeans.css">
    </HEAD>
    <body>

    <h1>NetBeans Sources - Mercurial Overview</h1>

    <p>
        <A HREF="http://www.selenic.com/mercurial/wiki/">Mercurial</a> is the tool you use to access the NetBeans sources here on netbeans.org, either from
        the command line, or even using the Mercurial support built into the IDE itself!
        Before you start you should know how the sources are organized, both in terms
        of directory <A HREF="../../community/sources/structure.html">structure</a>.
        You can
        <A HREF="http://hg.netbeans.org/">browse the Mercurial repositories</A> online
        to get an overview of available repositories. 
        For more general information, read the book <a href="http://hgbook.red-bean.com/">Distributed revision control with Mercurial</a>.
        
    </p>

    <h2>Legal Notice</h2>

    <p>
    By downloading builds, source code, or accessing the Mercurial repository, you
    acknowledge that you have read, understood, and agree to be bound by the
    terms and conditions of the applicable licenses:
    </p>
    <p>
    All the souce code made available on netbeans.org is provided to you
    under the terms and conditions of <a href="../../cddl-gplv2.html">Common 
    Development and Distribution License (CDDL) v1.0 and the GNU General Public License (GPL) v2</a>.
    </p>
    <p>
    The software developed at netbeans.org may make use of third-party
    software components which are distributed under different licenses than
    the CDDL.  Examples of such components may include Apache Ant,
    Apache Tomcat, JUnit, JavaHelp runtime, Java Compiler - a wrapper around the JDK java compiler.
    </p>
    <p>
    All those components are either open source software or redistributable
    binary libraries.  They are included in the builds, source code
    downloads and the Mercurial repository.  Their licenses can be found in the

    <ul>
      <li>For the IDE installation the license is in the top-level directory</li>
      <li>For a module source directory the license texts are in a
          subdirectory named &quot;external&quot;</li>
    </ul>

    <p>
    It is your obligation to read and accept all such terms and conditions
    prior to the use of the builds and source code made available on the
    netbeans.org website or in the netbeans.org Mercurial repository.
    </p>

    <h2>Getting the Sources</h2>

    <p>These guides show you how to get anonymous access to the NetBeans.org Mercurial repository.
        If you do not have Mercurial installed, first
        <A HREF="http://www.selenic.com/mercurial/wiki/index.cgi/BinaryPackages">download</A>
        and install one of the available ports for your operating system.
    <P>
    <UL>
        <LI><B>Using NetBeans</B> <I>(Recommended)</I> &mdash; You can use the NetBeans IDE
        itself to get the sources. This method is the same for every operating system.
        Mercurial support is available on the Update Center for NetBeans 6.0
        and standard for NetBeans 6.1+. Read: <a href="http://wiki.netbeans.org/HgNetBeansSources">Using 
        Mercurial to work with NetBeans Sources in the IDE</a>
        <LI> <B>From the command line</B> run the following command to get the repository.
            <PRE class='examplecode'>$ hg clone http://hg.netbeans.org/main</PRE>
    </UL>

    <h2>Authenticated Push Access</h2>
    <p>
    Using the anonymous login, you can clone, edit and use the sources on your computer.
    To contribute your changes to the NetBeans repository
    without submitting patches and relying on other people to commit them,
    you'll need a free named account with push (write) privileges.
    The only difference from the anonymous access is
    that you enter your username and a non-blank password.
    If you think you should have a push account,
    please see <A HREF="../contribute/hg.html">Getting Mercurial Push Access</A>.

    </BODY>

</HTML>
