<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <!-- Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved. -->
    <!--     Use is subject to license terms.-->
<html>
<!--
Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
-->
    <head>
        <meta http-equiv="content-type" content="text/html; charset=utf-8">
        <title>NetBeans IDE 7.2, Java ME Applications</title>
        <meta name="description" content="List of resources for creating mobile applications using NetBeans IDE 7.2">
		 <meta http-equiv="content-type" content="text/html; charset=UTF-8">
        <link rel="stylesheet" href="../../../netbeans.css">
    </head>
    <body>
        <h1>NetBeans IDE 7.2 Java ME Applications</h1>
        
        <p>This page lists all documentation available for the Java ME functionality in NetBeans IDE 7.2.</p>
		<p>For additional information about NetBeans IDE 7.2, see <a href="../../../community/releases/72/index.html" title="NetBeans 7.2 Release Information">NetBeans IDE 7.2 Release Information</a> and <a href="../index.html" title="NetBeans IDE 7.2 Documentation">NetBeans IDE 7.2 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="splashscreen.html">Using Splash Screens in Java ME Applications</a></li>
                               <li><a href="http://wiki.netbeans.org/VisualMobileDesignerPalatteReference" target="_blank">Reference: Visual Mobile Designer Palette Guide</a></li>
                            </ul>
                          
                
                                      
                            <p class="orange bold">Creating Java ME Games</p>
                            <ul class="b-bottom-dashed">
                             <li><a href="http://wiki.netbeans.org/CreatingJavaMEGamesWithGameBuilder">Creating Mobile Games with the Java ME Game Builder</a></li>
                            </ul>
                             <p class="orange bold">Screencast</p>
                <ul >
                <li><a href="../../docs/javame/gamebuilder-screencast.html">Demo: Creating Mobile Games in NetBeans IDE</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="../../docs/javame/cdcemulator-setup.html">CDC Emulator Platform Setup Guide</a></li>
                <li><a href="http://www.oracle.com/technetwork/articles/javame/bluray-142687.html" target="_blank">Blu-ray Disc Application Development with Java ME Pt I: Creating Your First Application</a></li>
                <li><a href="http://www.oracle.com/technetwork/articles/javame/index-136413.html" target="_blank">Blu-ray Disc Application Development with Java ME Pt II: Responding to User Input</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="../../samples/mobile-svg.html">SVG Contact List</a></li>
					<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="../../trails/mobility.html">Java ME and Java Card Application Technology Trail.</a></li>
						<li><a href="http://www.oracle.com/technetwork/java/javame/overview/index.html" target="_blank">Oracle Technology Network - Java ME Web Home</a></li>
                        <li><a href="http://wiki.netbeans.org/wiki/view/CommunityDocs">NetBeans Community Docs 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>
                <td class="valign-top" style="width: 50%;">
				 <p class="orange bold">Java ME Developer Blogs</p>
   				 <ul>
                     <li><a href="https://blogs.oracle.com/javamesdk/" target="_blank">Java ME SDK Developer Team Blog</a></li>
					 <li><a href="http://weblog.cenriqueortiz.com/java-me-midp-articles-tech-tips-source-code/">C. Enrique Ortiz's Mobile Java Weblog</a></li>
                     
   				</ul>
			    </td>
            </tr>
        </table>
        <p>If you are using NetBeans IDE 7.1, please see the <a href="../../71/javame/index.html">NetBeans 7.1 General Java ME Documentation Index</a>.</p>
        <!-- +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
        <hr>
    </body>
</html>
        
          
                               
			 