<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <!-- Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. -->
    <!--     Use is subject to license terms.-->
<html>
<!--
Copyright (c) 2009, 2014, Oracle and/or its affiliates. All rights reserved.
-->
    <head>
        <meta http-equiv="content-type" content="text/html; charset=utf-8">
        <title>NetBeans IDE 7.4, Java ME Applications</title>
        <meta name="description" content="List of resources for creating mobile applications using NetBeans IDE 7.3">
		 <meta http-equiv="content-type" content="text/html; charset=UTF-8">
        <link rel="stylesheet" href="../../../netbeans.css">
    </head>
    <body>
        <h1>NetBeans IDE 7.4 Java ME Applications</h1>
        
        <p>This page lists all documentation available for the Java ME functionality in NetBeans IDE 7.4.</p>
		<p>For additional information about NetBeans IDE 7.4, see <a href="../../../community/releases/74/index.html" title="NetBeans 7.4 Release Information">NetBeans IDE 7.4 Release Information</a> and <a href="../index.html" title="NetBeans IDE 7.4 Documentation">NetBeans IDE 7.4 Documentation</a>.</p>
        <p>For a list of documentation for the current release, see the <a href="../../trails/mobility.html">Java ME and Java Card Application Technology Trail</a>.</p>
		
		 <h2>All Tutorials and Demos</h2>
		 
		 <table width="95%" cellpadding="5">
            <tr class="valign-top">
            <td class="valign-top" style="width: 50%;">

                <!-- +++++++++++++++ left column +++++++++++++++ -->
                <p class="orange bold">Getting Started</p>
                 <ul class="b-bottom-dashed">
                                <li><a href="quickstart.html">NetBeans Java ME MIDP Development Quick Start 
                                Guide</a></li>
                                <li><a href="cdc-quickstart.html">NetBeans Java ME CDC Development Quick Start Guide</a></li>
                                <li><a href="../../docs/javame/java-card.html">NetBeans Java Card Development Quick Start Guide</a></li>
                            </ul>
               <p class="orange bold">Using Visual Mobile Designer Custom Components</p>
                   <ul class="b-bottom-dashed">
                               
                               <li><a href="http://wiki.netbeans.org/VisualMobileDesignerPalatteReference" target="_blank">Reference: Visual Mobile Designer Palette Guide</a></li>
                            </ul>
                          
                
                                      
                           
                             <p class="orange bold">Screencasts</p>
                <ul >
				<li><a href="./imp-ng-screencast.html">Demo: Support for IMP-NG Profile in NetBeans IDE</a></li>
				<li><a href="./nb_mesdk_screencast.html">Demo: Setting up NetBeans IDE for Mobile Development on Windows</a></li>
               
				</ul>

            </td>

            <td class="valign-top" style="width: 50%;">
                <!-- +++++++++++++++ right column +++++++++++++++ -->
                
                <p class="orange bold">Developing Java ME/CDC Applications</p>
                <ul class="b-bottom-dashed">
                <li><a href="cdcemulator-setup.html">CDC Emulator Platform Setup Guide</a></li>
               
                  </ul> 
				 <p class="orange bold">Developing Java Card Applications</p>
                 <ul class="b-bottom-dashed">
                 <li><a href="../../docs/javame/javacard.html">Java Card Quick Start Article</a></li>
                 <li><a href="http://www.oracle.com/technetwork/articles/javase/javacard-servlets-136657.html" target="_blank">Deploying Servlets on Smart Cards: Portable Web Servers with Java Card 3.0</a></li>
                 </ul>
               
                
                <p class="orange bold">Sample Applications</p>
                <ul class="b-bottom-dashed">
                    
					<li><a href="https://blogs.oracle.com/mobility_techtips/entry/mixing_midi_tone_and_sampled">Mixing MIDI, Tone, and Sampled Audio Using MMAPI</a></li>
                </ul>
				 
                                        
                
            </td>
            </tr>

        </table>
		 <!-- ++++++++++++ Other Resources and Training table ++++++++++++ -->
        <table cellspacing="3" width="95%">
            <tr class="valign-top">
                <td class="valign-top" style="width: 50%;">
                    <h2>Other Resources<a name="other"></a></h2>
                    <ul>
                        <li><a href="http://wiki.netbeans.org/JavaMESDKSupport">NetBeans wiki page on Java ME SDK Support</a></li>						
                        <li><a href="http://blogs.oracle.com/javamesdk/">Java ME SDK Developer Team Blog</a></li>
						<li><a href="http://www.oracle.com/technetwork/java/javame/index.html" target="_blank">Oracle Technology Network - Java ME Landing Page</a></li>
                       	<li><a href="http://community.java.net/mobileandembedded/" target="_blank">Java ME Mobile and Embedded Community</a></li>
                        <li><a href="http://forums.netbeans.org/javame-users.html" target="_blank">NetBeans Java ME User Forum</a> </li>
                    </ul>
                </td>
                
            </tr>
        </table>
        <p>If you are using NetBeans IDE 7.3, please see the <a href="../../73/javame/index.html">NetBeans 7.3 General Java ME Documentation Index</a>.</p>
        <!-- +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
        <hr>
    </body>
</html>
        
          
                               
			 