
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 26</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" >
<meta name="keywords" content="NetBeans, IDE, Platform, free, open source, developer" >
</head>
<body>
<style>
body {
		margin:5px 15px 5px 15px;
		font-size: 11px;
		font-family: Verdana, "Verdana CE",  Arial, "Arial CE", "Lucida Grande CE", lucida, "Helvetica CE", sans-serif;
		background-color:#e3eaf1;
		text-align:center;
}

#letter {width:533px;margin-left:auto;margin-right:auto;}
#head {background-image:url("http://services.netbeans.org/appl2/shared_images/head.png");width:533px;height:70px;background-repeat:none;}
#issue-date {padding-top:50px;text-align:center; color:white;}
#footer {background-image:url("http://services.netbeans.org/appl2/shared_images/footer.png"); width:533px;height:28px;background-repeat:none;}
#footer-text {padding-top:5px;color:#6a6b6d;text-align:center;}
#content {border-right:3px solid #747d9e;border-left:3px solid #747d9e; background-color:white; text-align:left; color:#6a6b6d; padding:13px 20px 13px 13px; }
#letter h1 {font-size: 14px; font-weight:normal; margin:3px 0px 5px 0px; padding:0px;color: #EE6B00; border-bottom:1px solid silver;}
#letter h2 {color:#2C3C79;font-size: 13px; font-weight:normal;margin:0px 0px 2px 0px;padding:0px; border:0px;}
#letter p {padding: 0px;margin:0px; text-align:justify;}
#letter a:link, a:visited { color: #045491; font-weight : normal; text-decoration: none;}
#letter a:link:hover, a:visited:hover  { color: #045491; font-normal : bold; text-decoration : underline;}
.item {margin-left:8px; margin-bottom:9px;}
.bold {font-weight:bold;}
#letter a.orange {color: #EE6B00;}
.align-right {text-align:right;}
.align-center {text-align:center;}
.edited {margin:15px -20px 0px -13px;padding-top:8px;text-align:center;}
.edge-top {background-color: #f0f7ff;padding:7px 12px 7px 7px;margin-bottom:10px; border:1px solid #747d9e;}
</style>


<div id="letter">
	<div id="head">
		<div id="issue-date" class="bold">
				Numéro # 26 - Feb 11, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3277">Intégrer JavaFX dans les projets Java sous Netbeans</a></h2>
						<p style="margin-left:8px;">
						JavaFX est un langage de script. Mais comment l'intégrer avec les applications Java existantes ? Dans cet article de Netbeans Zone, on montre comment coder en Java en utilisant JavaFX et intégrer le résultat dans la plateforme Netbeans.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3278">Un étudiant intègre Google dans la plateforme Netbeans</a></h2>
						<p style="margin-left:8px;">
						L'EDI Netbeans est une plateforme pour des outils comme le montre Piotr Tabor, un étudiant qui a crée un plugin qui intègre le support pour  les tampons de Protocol Google dans l'EDI Netbeans. Cet interview de Netbeans Zone explique pourquoi il s'est engagé dans ce projet et quelles sont les fonctionnalités de son plugin.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3274">Un correctif pour JDK Update 12 et les difficultés d'enregistrement de serveur</a></h2>
						<p style="margin-left:8px;">
						Rencontrez-vous des problèmes dans l'enregistrement des serveurs d'application dans l'EDI Netbeans ? Vince Kraemer a une solution.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3275">Top 17  raccourcis clavier pour Ruby and Rails dans Netbeans.</a></h2>
						<p style="margin-left:8px;">
						Jeff Dwyer utilise NetBeans pour Ruby et Ruby on Rails. Dans cette entrée de blog, il écrit sur ses raccourcis clavier favoris (et dans ses propres termes, "sexy") dans l'EDI Netbeans. Imprimer la page et garder le sous la main; ces raccourcis accelèrent votre travail !</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3276">Préparer l'environnement Ruby on Rails dans l'EDI Netbeans</a></h2>
						<p style="margin-left:8px;">
						Une entrée multipartite qui traite des étapes de l'installation de l'environnement Ruby on Rails dans l'EDI Netbeans et le développement des projets.</p>
					</div>
				<h1>Nouvelles de projet</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3282">Nouvelles versions traduites de  plugins Netbeans 6.5 disponibles !</a></h2>
						<p style="margin-left:8px;">
						L'équipe de traduction de Netbeans est heureuse d'annoncer la sortie de la nouvelle version des plugins du Centre de Mise à jour automatique  en Japonais et en Chinois simplifié. Les plugins localisés sont : UML, Maven, le support BlueJ Project , Importateur de projet JBuilder, JMX, JConsole, le supplort Axis2, Interactive UI Gestures Collector et la Collaboration de développeur. Vous pouvez obtenir les modules AUC localisés de deux manières : 
						<br>
<ul><li><a href="https://netbeans.org/downloads/index.html">Télécharger</a>  et installer l'EDI Netbeans 6.5 ML. Aller dans le menu Aide, selectionner <i> Vérifier les mise à jour</i>, et installer les modules mis à jours.
<li>Si vous avez déjà Netbeans installé, allez dans le menu Aide, selectionnez <i>Vérifier les mis à jour</i>, et installez les modules mis à jour.
Les plugins localisés se retrouvent aussi sous <i>Outils -> Plugins -> Mises à jours /Plugins disponibles</i>.
</ul>
Pour mieux connaitre le projet de Localisation du Centre de mise à jour de Netbeans 6.5 <a href="http://wiki.netbeans.org/NB65L10nUc">ici</a>, et obtenir le status complet des modules du Centre de mise à jour de Netbeans 6.5 <a href="http://wiki.netbeans.org/NB65StableModulesUC">ici</a>.</p>
					</div>
				<h1>Formation</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3279">Astuce technique: Police de la fenêtre de sortie NetBeans si petit ?</a></h2>
						<p style="margin-left:8px;">
						Changer la taille de la police dans la fenêtre de sortie de Netbeans est facile. Retrouvez ici comment le faire rapidement dans cet astuce de Tim Boudreau.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3280">SaaS en PHP: Service Yahoo News</a></h2>
						<p style="margin-left:8px;">
						Ce tutorial montre comment utiliser Netbeans 6.5 pour insérer  des opérations SaaS (Software as a Service) dans un fichier PHP.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3281">Séquence vidéo: Catalogue avec les services Web RESTful</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2498&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='33' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Carol Mcdonald montre comment construire un catalogue en utilisant les services web RESTful, JAX-RS, dojo, MySQL et Netbeans 6.5.</p><br style="clear:both;"/>
					</div>
	<div class="edited">
	Ce numéro vous a été envoyé par: Jeremie Bertolino<br/>Si vous ne désirez plus recevoir cette lettre d'information, <a href="https://netbeans.org/community/lists/top.html">des-inscrivez vous ici</a>
	</div>
	<div class="edited">
        Langues disponibles<br>
        <a href="https://netbeans.org/community/news/newsletter/index.html">English</a> | <a href="https://netbeans.org/community/news/newsletter/index_pt_BR.html">Brazilian Portuguese</a> | <a href="https://netbeans.org/community/news/newsletter/index_fr.html">French</a> | <a href="https://netbeans.org/community/news/newsletter/index_zh_CN.html">Chinese - simplified</a> | <a href="https://netbeans.org/community/news/newsletter/index_zh_TW.html">Chinese - traditional</a>
        </div>
	</div>
	<div id="footer">
		<div id="footer-text">
				Cette lettre d'information est aussi accessible à cette adresse  <a href="https://netbeans.org/community/news/newsletter/2009-02-11_fr.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive_fr.html">Archives des lettres d'information</a>
		</div>
	</div>

</body>
</html>