<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <!-- Copyright (c) 2012, 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.1, Java ME Applications</title>
        <meta name="description" content="List of resources for creating mobile applications using NetBeans IDE 7.1">
		 <meta http-equiv="content-type" content="text/html; charset=UTF-8">
        <link rel="stylesheet" href="../../../netbeans.css">
    </head>
    <body>
        <h1>NetBeans IDE 7.1 Java ME Applications</h1>
        
        <p>This page lists all documentation available for the Java ME functionality in NetBeans IDE 7.1.</p>
		<p>For additional information about NetBeans IDE 7.1, see <a href="../../../community/releases/71/index.html" title="NetBeans 7.1 Release Information">NetBeans IDE 7.1 Release Information</a> and <a href="../index.html" title="NetBeans IDE 7.1 Documentation">NetBeans IDE 7.1 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="svgtouch.html">Creating a Touch Enabled SVG UI for Java ME Devices</a></li>
                                <li><a href="filebrowser.html">Creating a Mobile Device File Browser</a></li>
                                <li><a href="loginscreen.html">Creating Mobile Login Screens</a></li>
                                <li><a href="smscomposer.html">Creating an SMS Composer Application</a></li>
                                <li><a href="pimbrowser.html">Creating a Personal Information Manager Application</a></li>
                                <li><a href="tableitem.html">Using Table Items 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">Using Java ME Client to Web Application</p>
                <ul class="b-bottom-dashed">
                                <li><a href="webtomobile.html">Mobile Client to Web Application Wizard: Creating a Client-Server Application</a></li>
						</ul>
				
                            
                            <p class="orange bold">Creating Java ME Games</p>
                            <ul >
                             <li><a href="mobilegame.html">Creating a Web Connected, Multi-Player Mobile Game Using NetBeans</a></li>
                             <li><a href="http://wiki.netbeans.org/CreatingJavaMEGamesWithGameBuilder">Creating Mobile Games with the Java ME Game Builder</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>
                <li><a href="http://java.sun.com/developer/technicalArticles/javame/bluray/" target="_blank">Blu-ray Disc Application Development with Java ME Pt I: Creating Your First Application</a></li>
                <li><a href="http://java.sun.com/developer/technicalArticles/javame/bluray/part2/" 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://java.sun.com/developer/technicalArticles/javacard/javacard-servlets/" target="_blank">Deploying Servlets on Smart Cards: Portable Web Servers with Java Card 3.0</a></li>
                 </ul>
                <p class="orange bold">Screencasts</p>
                <ul class="b-bottom-dashed">
                <li><a href="../../docs/javame/gamebuilder-screencast.html">Demo: Creating Mobile Games in NetBeans IDE</a></li>
				<li><a href="svgtouch-screencast.html">Demo: Creating a Touch Enabled SVG UI for Java ME Devices</a></li>
                 </ul>
                
                <p class="orange bold">Sample Application</p>
                <ul class="b-bottom-dashed">
                    <li><a href="../../samples/mobile-game-builder.html">Mobile Game Builder</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://developers.sun.com/mobility/" target="_blank">Mobility Resource Center</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 Blog</p>
   				<ul>
                     <li><a href="http://blogs.oracle.com/kharezlak/" target="_blank">Karol Harezlak's Inside NetBeans Mobility Blog</a></li>
                     
   				</ul>
			    </td>
            </tr>
        </table>

        <!-- +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
        <hr>
    </body>
</html>
        
          
                               
			 