Blog de Jérémie Bertrand

Lancement d’AppConfig Code Generator

laedit — Tue, 22 Mar 2011 14:30:08 +0000

Petite news (depuis fort longtemps malheureusement…) pour annoncer le lancement du projet AppConfig Code Generator !

Hébergé sur codeplex (http://appconfigcodegen.codeplex.com/), ce projet est un Custom Tool pour Visual Studio 2008 et 2010 permettant la génération automatique en C# ou VB.NET d’une classe d’accès aux appSettings et connectionStrings contenu dans le fichier App.config du projet.

Codé en une journée, ce projet est encore jeune et ne demande qu’à être amélioré grâce à vos idées, donc n’hésitez pas à aller sur le site pour dire ce que vous en pensez !

Dessiner un PNG avec le Compact Framework

laedit — Wed, 01 Sep 2010 13:09:25 +0000

Qui n’a jamais dû dessiner une image transparente avec le Compact Framework sur Windows Mobile ou pire Windows CE ?
Le plus simple est d’utiliser une image PNG. Le problème étant que le Compact Framework ne prend pas en charge la transparence.

Il faut donc utiliser les dlls de l’OS afin de remédier à ce petit problème.

Après un petit tour sur le web,on trouve assez rapidement qu’il faut utiliser l’API Imaging. On peut également utiliser l’API Alpha blend afin de rendre transparente une image qui ne l’est pas, mais les possibilités ne sont pas aussi étendues qu’avec une image PNG.

Une fois cette info en poche, un petit tour sur PInvoke.net nous apprend qu’il faut utiliser un object COM nous permettant par la suite d’avoir une interface IImage, représentant une image transparente, et une interface IImagingFactory, permettant de créer des objets de type IImage.
L’imprémentation en est très bien expliqué dans le post Alphablending with NETCF de Chris Lorton.

Une fois les diverses structures et interfaces en place, on lance le projet et tout marche, on a de la transparence !

Enfin, pas pour tous. Vous n’êtes peut-être pas tombé dessus, mais en changeant les coordonnées du rectangle de destination d’une IImage l’exception ArgumentException avec le message très explicite « 0x80070057″ peut être levée.
Une fois connue, la raison en est simple : le rectangle de destination ne fonctionne pas exactement de la même manière que dans les autres fonctions de dessin.
Le rectangle est normalement composé de 4 entiers : X et Y représentent les coordonnées du point situé en haut à gauche de la zone à dessiner et Width et Height représentent la largeur et la hauteur de la zone à dessiner.

Mais dans le cas présent, si X et Y gardent la même fonction, c’est Width et Height qui sont différents. En effet, ils ne correspondent pas à la largeur et la hauteur du rectangle dont le point en haut à gauche est situé à X,Y mais à 0,0.

Il faut donc ajouter X à la largeur voulue et Y à la hauteur voulue :

Rectangle(X, Y, X + Width, Y + Height)

Par exemple, j’ai une image avec ce rectangle de destination: 0, 0, 50 ,50.

Si je souhaite la déplacer, j’aurais donc ce rectangle de destination: 20, 30, 20 + 50, 30 + 50, afin de conserver les proportions de l’image.

Update :
Un petit plus afin de gagner du temps lors du dessin, pensez à utiliser la méthode SetImageFlags avec en paramètre ImageFlagsCaching de l’objet IImage.
Plus d’informations ici (attention, code non-managé).

Bonne chance avec vos projets Compact Framework !

Amazon Product Advertising API en C#

laedit — Sat, 07 Aug 2010 18:37:34 +0000

Avez-vous déjà voulu requêter les web services d’amazon afin de récupérer le titre d’un film ou d’un livre ?

Si oui, vous vous êtes sûrement déjà confrontés au brouillard de tous les web services amazon afin de trouver le bon, et après il faut encore trouver son nom ( car ils ont tendance à changer ) et à trouver quelques bons exemples de codes encore valable, voire la bonne adresse du WSDL.

Après une petite après-midi de recherche, j’ai pu trouver ce que je voulais et arriver au résultat voulu : récupérer toutes les informations d’un produit à partir de son code EAN (code-barre).

Après avoir passé quelques heures sur le site d’amazon et m’être aperçu que tous les exemples ne sont plus valable, je me suis tourné vers google. Et après quelques recherches infructueuses, j’ai trouvé la perle : le code-source et le guide pour réaliser le même code.

Merci Oren Trutner : https://flyingpies.wordpress.com/2009/08/01/17/

Au passage, il faut se créer un compte pour utiliser les web services d’Amazon. Vous pouvez vous en créer un gratuitement à cette adresse : http://aws.amazon.com/ en cliquant sur le lient « Create an AWS Account » en haut à droite. Une fois la création effectuée, allez dans Account->Security Credentials et gardez sous la main l’Access Key ID et la Secret Access Key dans la partie Access Credentials, vous en aurez besoin par la suite.

Au niveau du code, au début rien de bien compliqué : le WSDL est dispo à l’adresse http://webservices.amazon.com/AWSECommerceService/AWSECommerceService.wsdl.
Il suffit de créer une nouveau projet dans Visual Studio et d’ajouter une référence de service avec cette uri, en asynchrone ou non selon vos goûts.
On obtient donc de jolies classes de proxy, que l’on peut donc utiliser afin de requêter Amazon.

class Program
{
// your Amazon ID's
private const string accessKeyId = "AccessKeyId";
private const string secretKey = "SecretAccessKey";

// the program starts here
static void Main(string[] args)
{

// create a WCF Amazon ECS client
AWSECommerceServicePortTypeClient client = new AWSECommerceServicePortTypeClient(
new BasicHttpBinding(),
new EndpointAddress("http://webservices.amazon.com/onca/soap?Service=AWSECommerceService"));

// prepare an ItemSearch request
ItemSearchRequest request = new ItemSearchRequest();
request.SearchIndex = "All";
request.Keywords = "3700259800655";
request.ResponseGroup = new String[] { "Large" };

ItemSearch itemSearch = new ItemSearch();
itemSearch.Request = new ItemSearchRequest[] { request };
itemSearch.AWSAccessKeyId = accessKeyId;

// issue the ItemSearch request
ItemSearchResponse response = client.ItemSearch(itemSearch);

// write out the results
foreach (var item in response.Items[0].Item)
{
Console.WriteLine(item.ItemAttributes.Title);
}

Console.ReadLine();

Pour information, la liste de tous les SearchIndex est ici : http://docs.amazonwebservices.com/AWSEcommerceService/4-0/ApiReference/SearchIndexValues.html. Il faut tout de même lui ajouter All, qui correspond à une recherche sur toutes les catégories.

Mais le code précédent ne fonctionne pas. Pas avant d’avoir bidouillé un peu. Car ce qu’Amazon ne dit pas sur son site (ou alors il fallait chercher pendant encore quelques heures), c’est toute la partie authentification des messages SOAP qu’il faut mettre en place.
Trois classes vont rendre cela possible :

AmazonSigningMessageInspector : implémente IClientMessageInspector et permet de modifier la requête avant son envoi. Elle va donc rajouter les headers.
AmazonSigningEndpointBehavior : implémente IEndpointBehavior et permet d’ajouter le bon MessageInspector au bon moment.
AmazonHeader : hérite de MessageHeader et est utilisée par le MessageInspector pour ajouter les headers.

Voilà la partie du code de AmazonSigningMessageInspector ajoutant les headers :

public object BeforeSendRequest(ref Message request, IClientChannel channel)
{
// prepare the data to sign
string operation = Regex.Match(request.Headers.Action, "[^/]+$").ToString();
DateTime now = DateTime.UtcNow;
string timestamp = now.ToString("yyyy-MM-ddTHH:mm:ssZ");
string signMe = operation + timestamp;
byte[] bytesToSign = Encoding.UTF8.GetBytes(signMe);

// sign the data
byte[] secretKeyBytes = Encoding.UTF8.GetBytes(secretKey);
HMAC hmacSha256 = new HMACSHA256(secretKeyBytes);
byte[] hashBytes = hmacSha256.ComputeHash(bytesToSign);
string signature = Convert.ToBase64String(hashBytes);

// add the signature information to the request headers
request.Headers.Add(new AmazonHeader("AWSAccessKeyId", accessKeyId));
request.Headers.Add(new AmazonHeader("Timestamp", timestamp));
request.Headers.Add(new AmazonHeader("Signature", signature));

return null;
}

Cela permettra de mettre en place un header de ce type :

xmlns:aws="http://security.amazonaws.com/doc/2007-01-01/">
YOURACCESSKEYIDHEREX
2009-08-15T23:59:59Z
SZf1CHmQnrZbsrC13hCZS061ywsEXAMPLE

Il suffit ensuite de modifier la façon d’appeler le web service pour que tout roule :

// create a WCF Amazon ECS client
BasicHttpBinding binding = new BasicHttpBinding(BasicHttpSecurityMode.Transport);
binding.MaxReceivedMessageSize = int.MaxValue;
AWSECommerceServicePortTypeClient client = new AWSECommerceServicePortTypeClient(
binding,
new EndpointAddress("http://webservices.amazon.com/onca/soap?Service=AWSECommerceService"));

// add authentication to the ECS client
client.ChannelFactory.Endpoint.Behaviors.Add(new AmazonSigningEndpointBehavior(accessKeyId, secretKey));

Et afin de pouvoir « localiser » les web services, j’ai créée une petite classe AmazonEndpointAdress recensant toutes les adresses des endpoint des web services Amazon, accessibles ici : http://docs.amazonwebservices.com/AWSECommerceService/latest/DG/index.html?AnatomyOfaRESTRequest.html.
Bien entendu, votre fichier App.config doit comporter tous les endpoint correspondant.
Et au final, le code d’appel ressemble à celle-ci :

AWSECommerceServicePortTypeClient client = new AWSECommerceServicePortTypeClient(
binding,
new EndpointAddress(AmazonEndpointAdresses.FR));

Et voilà !

Vous pouvez maintenant rechercher n’importe quel produit sur n’importe quel site d’Amazon !

Les sources sont disponibles ici : http://laedit.ftp-developpez.com/CSharp/Amazon/AmazonProductAdvtApiWcfSample.zip.

Convertir des fichiers XPS en PDF

laedit — Tue, 08 Jun 2010 15:20:24 +0000

Pour une fois, ce post ne parlera pas de développement. Enfin si, mais indirectement.

Vous êtes-vous déjà retrouvé à devoir convertir des fichiers XPS en PDF ?
Vous avez probablement utilisé une imprimante PDF telle que PDFCreator ou CuteWriter. Et cela à fonctionné.

Mais si vous utilisez Reflector et son addin SequenceViz afin d’exporter rapidement vos diagrammes de séquences, les fichiers XPS générés donnent une page blanche (ou presque) une fois imprimé en PDF.

Après quelques heures de recherches sur le net et de tests de diverses méthodes (sites web de conversion, programmes divers, imprimantes PDF) donnant des résultats pas toujours probant, j’ai fini par mettre la main sur un site qui allie la qualité à la rapidité.

Il suffit d’indiquer le fichier à convertir ainsi que son adresse mail afin de pouvoir récupérer le document converti, et en moins de deux minutes le résultat est là.

Voilà l’adresse du site : http://pdf.tchwork.com/fr/

Petit plus, le site gère aussi la conversion des formats suivants en PDF : .doc, .docx, .rtf, .xls, .ppt, .ps, .eps, .pdf, .dwg, .dwf, .dst, .xps, .odt, .sxw, .sdw, .jtd, .hwp, .wps, .ods, .sxc, .sdc, .dif, .dbf, .slk, .csv, .wk1, .123, .pxl, .wb2, .odp, .sxi, .sda, .sdd, .sdp, .cgm, .odg, .sxd, .dxf

Guide de programmation MEF

laedit — Mon, 31 May 2010 08:00:00 +0000

Après plus d’un mois de traduction, relecture et corrections diverses, je viens enfin de terminer un joli petit dossier sur l’utilisation de MEF (Managed Extensibility Framework), le framework permettant de créer facilement une application pouvant être étendue par le biais de plugins.

Sans plus attendre, voici le lien vers l’article : http://laedit.developpez.com/CSharp/MEF/Programming_Guide/

Et le sommaire :

I. Introduction
I-A. Qu’est-ce que MEF
I-B. Quels sont les problèmes que MEF peut résoudre
I-C. Comment fonctionne MEF
I-D. Vue d’ensemble de l’architecture

II. Guide de programmation MEF
II-A. Héberger MEF dans une application
II-A-1. Ajout d’une Part directement dans le container
II-A-2. Ajout en utilisant un AssemblyCatalog
II-B. Définition des Composable Parts et des contrats
II-B-1. Composable Part
II-B-2. Contrats
II-B-2-1. Contrats d’interface / abstraits
II-B-3. Assemblage de contrats
II-C. Déclaration des exports
II-C-1. Export de Composable Part
II-C-2. Export de propriétés
II-C-3. Export de méthodes
II-C-4. Héritage d’export
II-C-5. Découverte de Composable Parts privées
II-D. Déclaration des imports
II-D-1. Import de propriétés
II-D-2. Paramètre de constructeur
II-D-2-1. Import de paramètres
II-D-3. Import de champs
II-D-4. Imports optionnels
II-D-5. Import de collections
II-D-6. IPartImportsSatisfiedNotification
II-E. Imports différés
II-F. Exports et métadonnées
II-F-1. Ajouter des métadonnées à un export
II-F-1-1. Utiliser l’attribut ExportMetadata
II-F-1-2. Utiliser un attribut d’export personnalisé
II-F-2. Importer des métadonnées
II-F-2-1. Utiliser des métadonnées fortement typées
II-F-2-2. Utiliser des métadonnées faiblement typées
II-F-2-3. Le filtrage des métadonnées et l’attribut DefaultValueAttribute
II-G. Utilisation des catalogues
II-G-1. AssemblyCatalog
II-G-2. DirectoryCatalog
II-G-3. AggregateCatalog
II-G-4. TypeCatalog
II-G-5. DeploymentCatalog – uniquement dans Silverlight
II-G-6. Utilisation d’un catalogue dans un Container
II-H. Catalogues filtrés
II-I. Cycle de vie des Parts
II-I-1. Shared, Non Shared et propriété
II-I-2. Disposer le container
II-I-3. Container et références des Parts
II-I-4. Scoped operations et récupération rapide des ressources
II-I-5. Hiérarchie des containers
II-I-6. Ordre de disposition
II-I-7. AddPart / RemovePart
II-J. Recomposition
II-J-1. Mises en garde
II-J-2. La recomposition et Silverlight
II-K. Requêter le CompositionContainer
II-K-1. GetExportedValue
II-K-2. GetExport
II-K-3. GetExportedValueOrDefault
II-L. Composition Batch
II-M. Débogage et diagnostics
II-M-1. Diagnostiquer les problèmes de composition
II-M-1-1. Problèmes liés au rejet
II-M-1-2. Dump Composition State
II-M-1-3. Trouver les root causes probables
II-M-1-4. Débogage des proxies
II-M-2. Mefx : outil d’analyse en ligne de commande
II-M-3. Tracer les informations de composition
II-N. FAQ
II-N-1. Comment avoir des exports utilisant un objet Type
II-N-2. Comment utiliser des containers imbriqués

III. Fonctionnalités spécifiques à Silverlight
III-A. Héberger MEF dans Silverlight en utilisant le CompositionInitializer
III-A-1. Utilisation de CompositionInitializer depuis des éléments XAML
III-A-2. Mises en garde dans l’utilisation de CompositionInitializer.SatisfyImports
III-B. Redéfinir la configuration de l’hôte
III-B-1. Redéfinition grâce aux catalogues
III-B-1-1. Configurer la découverte des Parts dans le XAP courant
III-B-2. Redéfinition grâce à un container
III-C. Instanciation dynamique et ExportFactory
III-C-1. ExportFactory
III-C-2. ExportLifetimeContext
III-D. Partitionnement d’application avec le DeploymentCatalog
III-D-1. DeploymentCatalog
III-D-2. Télécharger des Parts après le démarrage de l’application
III-D-3. Composer dynamiquement les Parts téléchargées et utiliser la recomposition
III-D-4. Téléchargement des Parts à la demande après démarrage de l’application et basé sur les actions de l’utilisateur
III-D-5. Gestion des erreurs durant le téléchargement
III-D-6. Mise à jour de la progression
III-D-7. Annulation du téléchargement
III-D-8. Utilisation du DeploymentCatalog quand l’application est hors-ligne ou Out of Browser
III-D-9. Mises en garde contre l’utilisation du DeploymentCatalog

IV. Codes sources et exemples
V. Liens
VI. Remerciements
VII. Contact

Utiliser Business Objects dans une application C#

laedit — Thu, 15 Apr 2010 07:48:01 +0000

Vu que je me retrouve embarquer là dedans pour des raisons professionnelles, et que j’ai galéré à trouver des infos, voilà comment faire pour utiliser Business Objects XI R2 dans une application C#.

Première étape, et non des moindres, installer BO.

Je ne vais pas détailler le processus ici, je préfère me concentrer sur du technique. Et puis c’est pas bien compliqué :p

Une fois l’installation finie, des dlls ont été installés dans le dossier System32, d’autres se retrouvent dans le GAC (C:\WINDOWS\assembly), tandis que d’autres encore sont présentes dans un des dossiers du dossier d’installation de BO, qui est par défaut « C:\Program Files\Business Objects\BusinessObjects Enterprise 11.5\win32_x86\ ».
[Update] D’autres dlls (pour les types de fichiers par exemple), sont présentes dans le dossier « C:\Program Files\Business Objects\common\3.5\managed ».

Parmi les dlls présentes dans le GAC, trois vont nous intéresser :

CrystalDecisions.Enterprise.dll
CrystalDecisions.Enterprise.Framework.dll
CrystalDecisions.Enterprise.InfoStore.dll

Ce sont celles qui vont nous permettre de faire des requêtes dans l’InfoStore de BO et ainsi récupérer, modifier ou supprimer divers objets BO.

Pour tester tout ça, il suffit maintenant de créer une application C#. Une application console fera l’affaire.

Ne pas oublier de référencer les trois dlls citées précédemment.

Et maintenant place au code :

// Création d'un sessionManager, c'est lui qui va nous permettre de nous identifier
SessionMgr boSessionMgr = new SessionMgr();

try
{
// Connexion à un serveur BO et récupération de la session [login] [mot de passe] [CMS name] [type d'authentification]
EnterpriseSession boEnterpriseSession = boSessionMgr.Logon("administrator", string.Empty, "VMSqlServer05", "Enterprise");

// Récupération d'un InfoStore afin de faire des requêtes
InfoStore boInfoStore = new InfoStore(boEnterpriseSession.GetService(SERVICE_INFOSTORE));
// Récupération d'une liste d'objets BO grâce à une requête dans l'InfoStore
InfoObjects boObjects = boInfoStore.Query("Select * From CI_INFOOBJECTS WHERE SI_KIND != 'Inbox' AND SI_KIND != 'PersonalCategory' ORDER BY SI_ID");

// Affichage des CUID et ID des objets
foreach (InfoObject infoObject in boObjects)
{
Console.WriteLine(infoObject.CUID + " : " + infoObject.ID);
}

Console.WriteLine();
Console.WriteLine("Modification d'un objet");

// Modification du titre du premier objet récupéré
// Attention, dans BO les listes d'objets (InfoObjects) commencent à 1 et non à 0
boObjects[1].Title = newTitle;
// Enregistrement des modifications dans l'InfoStore de BO
boInfoStore.Commit(boObjects);

Console.WriteLine();
Console.WriteLine("Objet modifié");

}
catch (COMException COMEx)
{
Console.WriteLine("ErrorCode: " + COMEx.ErrorCode);
Console.WriteLine("Message: " + COMEx.Message);
Console.WriteLine("StackTrace: " + COMEx.StackTrace);
}

Console.ReadLine();

Ce code détaillé permet donc de se connecter à BO, de récupérer une liste d’objet et de modifier l’un d’entre eux. Histoire de connaître les bases des relations entre BO et C#

Si une erreur survient lors de l’instanciation du SessionMgr, c’est que la dll EnterpriseFramework.dll, qui est présente dans le dossier « win32_x86″ du dossier d’installation de BO, n’a pas été installée. Il faut donc le faire via la ligne de commande « regsvr32 EnterpriseFramework.dll ».

Et pour finir, voici quelques bons liens :

Pro Crystal Enterprise/Business Objects XI programming Par Carl Ganz : aperçu d’un très bon livre sur la programmation avec BO
Querying the Busines Objects XI CMS InfoStore Database Tables : un très bon tips sur les requêtages des tables de l’InfoStore
La doc officielle de Business Objects XI R2
La doc officielle chez SAP avec deux sections intéressantes :
.NET SDK Developer Guides and API References
Object Model Diagrams

J’espère qu’avec ceci vous ne perdrez pas autant de temps que moi à trouver des informations sur comment utiliser BO via une application C# !

Twoolr : toutes les statistiques sur votre compte twitter

laedit — Wed, 28 Apr 2010 06:58:03 +0000

Des statistiques d’utilisation aussi bien que des statistiques de réseau, en passant par quel heure/jour/semaine/mois vous êtes le plus actif, quels clients vous utilisez, les liens que vous avez envoyés, qui vous réponds le plus, etc…

Même si toutes ne sont pas forcément utiles (en tout cas pour des particuliers), ça s’avère tout de même intéressant à essayer.

Twoolr est actuellement en phase beta et nécessite un token, par chance 10 sont disponibles en passant par l’url suivante : http://laedit.twoolr.com

Bonne twittistiques !

Créer un addin pour Firefox

laedit — Mon, 26 Apr 2010 21:03:06 +0000

Même si à première vue la création d’un addin pour Firefox peut paraître simple, certaines choses sont à connaître si on ne veut pas galérer plus que nécessaire. Voilà donc une liste de truc et astuces / tutoriels qui vous aidera à développer plus facilement des plugins pour Firefox.

Tout d’abord, voici un tutoriel sur BornGeek détaillant au pas à pas la création d’un addin pour Firefox. Très bien fait, il suffit à lui seul pour la création d’addins basiques.

En parallèle, le pôle développeur du site des addins de Firefox comprend des tutoriels ainsi que des articles assez intéressants, de même que l’espace développeur de Mozilla contient toute la documentation requise.

Mais certaines choses, même si elles ne sont pas obligatoires, valent mieux pour notre addin quand elles sont respectées. Je pense par exemple à la partie javascript de l’addin, certaines règles sont à respecter pour une meilleure intégration avec Firefox. Mark A. Ziesemer a rédigé un article sur la question, tandis qu’un guide de programmation est présent sur l’espace développeur de mozilla.

Une chose à connaître aussi est le cache de Firefox. Mettons par exemple que notre addin va contacter un fichier XML distant afin de récupérer des informations. Le cache de Firefox va fausser cette récupération, faisant croire à l’addin que le fichier n’a pas été modifié alors qu’en réalité c’est le cas. Il suffit alors d’utiliser la fonction Math.random() en javascript, et d’ajouter le résultat en tant que paramètre de l’url, afin de faire croire à Firefox que l’url n’est jamais la même. Ainsi nous n’aurons pas le contenu du cache mais le vrai fichier XML.

"http://www.example.com/toolbar/infos.xml?"+Math.random()

Une autre chose à savoir est que l’utilisation de la méthode Load de XMLDOM sur une fichier distant peut provoquer une erreur de sécurité, ce qui n’est pas le cas avec un XMLHttpRequest. Ce dernier est donc à privilégier.

La méthode setTimeout est dépréciée par Mozilla, il faudra donc utiliser à la place une classe interne. Il s’agit de la classe timer, qui s’instancie de la façon suivante :

var timer = Components.classes["@mozilla.org/timer;1"].createInstance(Components.interfaces.nsITimer);

Et pour lancer un compte à rebours, on peut utiliser sa méthode initWithCallback :

timer.initWithCallback(loadEvent, 2000, Components.interfaces.nsITimer.TYPE_ONE_SHOT);

loadEvent est un objet implémentant la méthode notify, qui sera utilisée par le timer :

var loadEvent = {
notify: function(timer)
{
alert('fin du timer');
}
};

Dans cet exemple, au bout de 2 secondes une fenêtre s’affichera, marquant « fin du timer ».

Un service pratique est celui des observers, permettant entre autre de savoir quand votre addin a été désinstallé.
Il faut tout d’abord instancier ce service :

var observerService = Components.classes['@mozilla.org/observer-service;1'].getService(Components.interfaces.nsIObserverService);

Il faut ensuite rajouter un observer, en définissant un objet définissant une méthode observe, ainsi que le type de l’observer :

observerService.addObserver(uninstallObserver, "em-action-requested", false);

uninstallObserver est l’objet implémentant la méthode observe, regardons son code :

L’id du plugin ayant levé cet appel est récupéré puis comparé à l’id de notre plugin (PLUGIN_ID est une constante ayant pour valeur l’id du plugin définit dans le fichier install.rdf). Si c’est bien notre plugin qui est à la source de cet appel, et si l’action est la désinstallation de ce plugin, alors les préférences du plugin appartenant à la branche « extensions.toolbar » sont supprimmées.

Pour rester sur les préférences, qui sont déjà vues dans le tutoriel de BornGeek, un autre tutoriel sur rietta.com les décrit plus en détail, ainsi que la documentation officielle sur mozilla.org.
Avec tout ça, plus aucune excuse pour ne pas les utiliser dans votre addin !

Une autre chose à connaître est l’eventListener, qui permet par exemple de lancer une action lors du chargement de Firefox. Combiné aux préférences, ça permet par exemple d’ouvrir un onglet avec une page vers votre site lors du premier lancement de Firefox après avoir installé votre addin.
Il faut tout d’abord ajouter un eventListener :
window.addEventListener("load", eventLoad, false);
Avec le code précédant, on se branche sur l’événement load de Firefox. eventLoad est une méthode qui sera appelée à ce moment là.

function eventLoad ()
{
if(preferencesService.getBoolPref(PREF_FIRSTRUN))
{
preferencesService.setBoolPref(PREF_FIRSTRUN, false);
timer.initWithCallback(loadEvent, 2000, Components.interfaces.nsITimer.TYPE_ONE_SHOT);
}
}

PREF_FIRSTRUN est une constante contenant le nom de la préférence qui va indiquer si c’est le premier lancement de Firefox depuis l’installation de l’addin. Si c’est le cas, la préférence est modifiée, et un compte à rebours est déclenché via le timer. Il suffira alors de mettre le code suivant dans loadEvent afin d’ouvrir un nouvel onglet :

gBrowser.selectedTab = gBrowser.addTab("http://www.google.com");

Passons maintenant au déploiement et aux mises à jours.
Le premier est déjà abordé dans le tutoriel de BornGeek ainsi que sur mozilla.org et n’est pas bien compliqué. A partir de là vous pouvez tester votre addin.
Quand aux mises à jour, il suffit de connaître le process pour que ça passe tout seul. Il est décrit dans un autre article de BornGeek ainsi que sur mozilla.org.
L’ordre à retenir est le suivant :
– Ajout de la clé dans le fichier install.rdf via McCoy
– Création du XPI
– Récupération du hash du XPI
– Ajout du hash dans le fichier update.rdf dans la section correspondante
– Signature du fichier update.rdf via McCoy

Il ne faut pas retoucher le fichier update.rdf sous peine de devoir le resigner.

Pour le hash, il existe une exention shell pour windows, HashTab, qui permet d’avoir le hash d’un fichier à partir d’un simple clic-droit -> propriété.

Update:

Depuis j’ai eu à faire une chose dont je suis pas fier : ouvrir le menu lors du passage de la souris.
C’est pas ergonomique du tout et ça bouleverse les habitudes des utilisateurs, mais quand on décide pas…
Du coup, pour mettre ça en place je me suis d’abord dit que ça allait être simple, il y a sûrement un event onmouseover auquel préciser une méthode javascript et ça roulerait.
Bah en fait non. Bon, bah alors y’a plus qu’à rajouter un eventlistener sur le mouseover de l’élément que j’me suis dit. Oui, mais lors du chargement de la feuile .js, l’élément n’est pas encore défini. Solution : ajouter un eventlistener sur le load de la fenêtre, et dans le load, ajouter un eventlistener sur le mouseover de l’élément ciblé. Et dans le mouseover, on peut enfin ouvrir le menu.
Plus de code pour plus de comprégension :

Et voilà qui termine cette série de liens et trucs et astuces, en vous souhaitant un bon développement d’addin Firefox !

Code Header Designer

laedit — Mon, 07 Sep 2009 18:15:13 +0000

J’ai découvert ce week end une application assez sympathique. Elle n’a qu’un seul but mais le fait bien, elle permet de définir un header et un footer à rajouter/remplacer à des fichiers de codes.

Certes, ce n’est pas une chose que l’on fait souvent, mais quand on prend l’habitude de partager son code, c’est toujours bien de laisser une trace. Et même pour soi, garder certaines informations en entête peut être utile.

Présentation

En premier lieu, l’utilisateur va définir un header via un template, comme celui-ci par exemple :

/* ----------------------------------------------------------------------------
* [COMPANY NAME]
* ----------------------------------------------------------------------------
* [PRODUCT NAME]
* ----------------------------------------------------------------------------
* File: [AUTO:FILE]
* Author: [AUTO:AUTHOR]
* ----------------------------------------------------------------------------
*/

Entre crochet, ce sont des champs remplaçables. On définira donc par la suite leur valeur.
Les champs commençant par ‘AUTO:’ sont des champs automatiques : ils seront automatiquement remplacés par le programme, sans que l’utilisateur ai besoin de définir une valeur de remplacement.

De base, on dispose de deux champs auto :
– File qui va être remplacé par le nom du fichier
– Author qui va être remplacé par le nom d’utilisateur windows

Ensuite, on va donc définir les champs à remplacer via un DataGridView :

Il faut maintenant sélectionner les fichiers auxquels on veut appliquer le header. Pour cela, en haut de la fenêtre on va aller cliquer sur le bouton ‘Source Directory’ pour choisir un dossier. Généralement, ce sera un dossier d’une solution ou d’un projet. Une fois cela fait, on va sélectionner les fichiers via le bouton ‘Select files’. Là, on va pouvoir choisir un pattern de recherche des fichiers, qui par défaut recherche les fichier .cs. La liste des sous-dossiers va apparaître dans un TreeView à gauche tandis que les fichiers contenus dans le dossier sélectionné seront listés à droite. Il suffit de cocher un fichier pour l’inclure dans les fichiers auxquels le header sera appliqué. A noter, une option très pratique dans le menu : ‘Select all’, ‘Unselect all’.

Et voilà, on peut maintenant appliquer le header aux fichiers en cliquant sur le bouton ‘Go’ en bas à gauche de l’application. Une fenêtre de log est même présente afin de savoir si le header à pu être appliqué ou non et dans le dernier cas, de savoir pourquoi.

L’application propose aussi une gestion de sauvegarde et d’ouverture de fichier .headerx, comprenant le template et la liste de correspondances des champs avec leur valeur de remplacement.

Téléchargement : http://code.msdn.microsoft.com/HeaderDesigner

Ajouts

Etant un peu trop limité pour mon utilisation personnelle, j’y ai donc rajouté quelques petites choses.

Champs automatiques :
– Modification_Date : date de dernière modification du fichier.
– Creation_Date : date de création du fichier.
– Solution : nom de la solution si il y en a une.
– Project : nom du projet.
– Namespace : nom du namespace.
– Inherit : nom de la classe mère si il y en a une.
– Implements : nom des interfaces implémenté si il y en a.

Une petite aide à la saisie à aussi été intégrée dans l’éditeur de template, pour ne pas devoir avoir la documentation sous les yeux pour ajouter un champ automatique.

Le dossier source et les fichiers sélectionnés sont enregistrés dans le fichier .headerx, et sont donc reconnus lors de l’ouverture du fichier.

L’extension .headerx est associé à l’application, il suffit donc d’un double-clic sur un fichier .headerx pour l’ouvrir avec le Code Header Designer.

Téléchargement :
– installeur
– sources

Lien

Blog du créateur du Code Header Designer : http://colbyafrica.blogspot.com/

WebService PHP consommé par une application C#

laedit — Wed, 18 Mar 2009 20:57:48 +0000

Pour créer un WebService facilement en PHP, il faut travailler en PHP5 avec l’extension SOAP d’activée. Pour cela, le mieux est de travailler en local avec Wamp Server (Wamp 5), qui permet d’activer cette extension.

Une fois le matériel prêt, on va commencer par ouvrir notre éditeur de PHP préféré et d’écrire la classe qui être utilisé par le WebService.
Dans notre exemple, on va juste définir une petite classe chargée de faire une opération et une soustraction :

class Math
{

public function Add($a, $b)
{
return $a + $b;
}

public function Substract($a, $b)
{
return $a - $b;
}

}

Voilà donc les méthodes qui seront exposées part le WebService.
Il ne reste plus qu’à créer le serveur et la partie PHP sera terminée.
Pour cela, nous allons utiliser la classe SoapServer :

require 'Math.class.php';

// première étape : désactiver le cache wsdl lors de la phase de test
ini_set("soap.wsdl_cache_enabled", "0");

$wsdl = 'WebService.wsdl';
//Création du serveur SOAP avec le fichier WSDL
$server = new SoapServer($wsdl);
//Ajout de la classe Math dans les éléments proposés par le WebService
$server->setClass('Math');

//l'utilisation du WebService se fera toujours par la méthode POST
if ($_SERVER["REQUEST_METHOD"] == "POST")
{
$server->handle();
}
else //dans le cas contraire, la page affichera les méthodes proposées par le WebService
{
echo '

Ce serveur SOAP peut gérer les fonctions suivantes :

'.$func.'

';
}

Vous avez sûrement remarqué qu’on fait appel au fichier WebService.wsdl alors qu’on ne l’a pas encore créé. On va donc s’en charger maintenant. Le mieux pour cela est d’utiliser un logiciel qui va générer le fichier wsdl finale grâce à des informations qu’on lui aura apporté. Pour ma part j’utilise Altova XML Spy qui est disponible gratuitement en version d’essai.
Voilà donc ce que ça donne en version graphique :

La partie serveur est à présent terminée, attaquons nous au client .net en C#.

L’utilisation de Visual Studio 2008 est conseillé, il permet la génération automatique d’un proxy grâce a WCF à partir du fichier WSDL.
On va commencer par créer une application console. Ensuite, il suffit d’ajouter une un Service Reference en passant en adresse celle du fichier WSDL (http://localhost/WebServices/WebService.wsdl dans notre cas) et Math comme namespace pour la référence.

WCF a alors généré la classe MathServiceClient ainsi qu’un fichier de configuration qui vont nous servir à intéragir avec le WebService.
On va instancier cette classe :

MathServiceClient math = new MathServiceClient();

Puis on va simplement appeler nos deux méthodes :

Console.WriteLine(math.Add(5, 5));
Console.WriteLine(math.Substract(10, 5));

Et bien sûr, il ne faut pas oublier de fermer le client :

math.Close();

Et voilà, notre client .net consomme notre WebService PHP !

Les sources de cet article sont disponibles ici.