I- Introduction

          Dans les nombreuses nouveautés du WPF, nous retrouvons une série d’améliorations visuelles ainsi que diverses possibilités de configurations.

Nous verrons qu’elles sont ces améliorations en détails et comment les configurer ou les personnaliser.

Nous commencerons par le mode ClearTypeHint pour l’aspect visuel puis nous verrons les autres nouveautés en ce qui concerne l’amélioration de l’affichage du texte.

 

II- Le mode ClearTypeHint

          Le mode ClearTypeHint permet de lisser les polices et de permettre ainsi un affichage plus net. Nous avons donc la possibilité d’activer ce mode afin d’améliorer la qualité visuelle du texte.

Pour cela nous n’avons besoin que d’activer la propriété « RenderOptions.ClearTypeHint » correctement.

La classe « RenderOptions » nous permettra de contrôler le rendu du ou des objets :

 

III- Le bindable Run

          Dans le WPF 4, un « Run » pourra être binder afin d’éviter certains dysfonctionnements tel qu’un décalage d’une partie d’un texte, ou encore l’apparition d’espaces non voulus.

Un « Run » est un contrôle qui possède les mêmes caractéristiques qu’un « TextBlock » (mais qui ne peut pas être positionné). Pour ce faire nous l’imbriquerons donc dans un « TextBlock ».

Ce contrôle permet grâce à la propriété « Text » de spécifier le texte à afficher.

 

 

IV-Le mode TextFormating

          Le mode « TextFormating » améliore l’affichage des petites polices de caractères. Il est rattahcé à la propriété « textOptions » (il s’agit d’une classe qui permet de contrôler le comportement du rendu texte grâce à une série d’options).

Nous avons le choix entre deux propriétés pour ce mode :

· Ideal : il s’agit du rendu texte par défaut.

· Display : il s’agit du mode qui permet d’améliorer la qualité de l’affichage du texte (le texte sera plus propre une fois affiché)

 

 

V- SelectionBrush et SelectionOpacity

          Les propriétés « SelectionBrush » et « SelectionOpacity » peuvent être utilisées pour des TextBox, Rich TextBox, FlowDocumentPageViewer, FlowDocumentScrollViewer, FlowDocumentReader et PasswordBox.

La propriété SelectionBrush sert à définir la couleur du surlignement du texte. Nous pourrons également changer, si nous le désirons, le gradient du surlignage.

La propriété SelectionOpacity sert simplement à définir l’opacité du surlignage. En ce qui concerne l’étalonnage de l’opacité, avec une opacité de 1 nous ne verrons plus le texte.

· SelectionBrush :

· SelectionOpacity :

 

VI-Le CaretBrush

          Le CaretBrush est une propriété qui permet de changer la couleur du curseur d’insertion (la tickbar qui est par défaut noire). Cette propriété peut être utilisée sur une « TextBox », « RichTextBox », et une « PasswordBox » :

 

VII-Conclusion

          Ces petites nouveautés en ce qui concerne l’affichage peuvent s’avérer très utile lorsque nous avons besoin de manipuler du texte. Cela permet d’éviter certains dysfonctionnements d’affichage.

Ainsi, avec le WPF 4, nous pouvons maintenant aussi personnaliser certains petits détails tels que la tickbar ou encore la couleur ou même l’opacité d’un sur lignage, afin de personnaliser au maximum notre

application.

WPF, Visual Studio 2010

 

 

Le clipboard et le drag and drop sont des nouvelles fonctionnalités arrivées avec la version 4 de Silverlight.

Ici ces nouveautés permettent de faciliter la maniabilité et la fonctionnalité du Silverlight 4.0.

Ci-dessous vous pouvez observer le code nécessaire au bon fonctionnement de ces nouvelles fonctionnalités.

 

using System; using System.Collections.Generic; using System.Linq; using System.Net; using System.Windows; using System.Windows.Controls; using System.Windows.Documents; using System.Windows.Input; using System.Windows.Media; using System.Windows.Media.Animation; using System.Windows.Shapes; using System.Windows.Media.Imaging;   namespace _04_ClipboardAndDragDrop {     public partial class MainPage : UserControl     {         public MainPage()         {             InitializeComponent();         }           private void OnCopy(object sender, RoutedEventArgs e)         {             Clipboard.SetText(copyPasteBox.Text);         }           private void OnPaste(object sender, RoutedEventArgs e)         {             copyPasteBox.Text = Clipboard.GetText();         }           private void OnDragEnter(object sender, System.Windows.DragEventArgs e)         {                             }           private void OnDragOver(object sender, System.Windows.DragEventArgs e)         {                             }           private void OnDrop(object sender, System.Windows.DragEventArgs e)         {                     if(e.Data.GetDataPresent(DataFormats.FileDrop))                     {                            e.Handled = true;                 var files = e.Data.GetData(DataFormats.FileDrop) as IEnumerable<System.IO.FileInfo>;                 if (files == null)                     return;                   foreach (var file in files)                 {                     try                     {                         var img = new BitmapImage();                           img.SetSource(file.OpenRead());                         wrapPanel.Children.Add(new Image { Source = img, MaxWidth = 150, Margin = new Thickness(4) });                     }                     catch                     {                     }                 }              }         }     } }

 

Pour copier le texte rentré dans la TextBox il suffit juste d’appeler la méthode « SetText » de l’objet Clipboard.

private void OnCopy(object sender, RoutedEventArgs e) {      Clipboard.SetText(copyPasteBox.Text); }

 

Le résultat ainsi obtenu est présenté ci-dessous.

 

 

Il en est de même pour coller une sélection avec la méthode GetText().

private void OnPaste(object sender, RoutedEventArgs e) {      copyPasteBox.Text = Clipboard.GetText(); }

 

Cette nouvelle fonctionnalité n’a pas vraiment d’utilité étant donné que le très célèbre « CTRL+C » et  « CTRL+V » fonctionne parfaitement ! Mais dans le futur qui sait ? Peut être que cette nouveauté sera très utilisée dans une application donnée.

 

En ce qui concerne le Drag & Drop, ce contrôle est encore assez limité. En effet il nous est impossible de revenir en arrière du moment que le Drag & Drop est déjà effectué.

 

Comme le screenshot du dessus nous le montre, cette nouvelle fonctionnalité nous permet d’importer tout simplement des fichiers dans une application Silverlight 4.0 grâce à un simple glissé-déposer.

Cette fonctionnalité pourrait tout à fait être implémentée sur une plateforme de rendu de projet ou bien sûr, comme présenté dans l’exemple, être intégrée dans une application visant à l’upload de fichiers.

 

 

En conclusion, nous pouvons dire que de par ces nouvelles fonctionnalités, Silverlight exprime sa volonté d’améliorer son interface avec les utilisateurs. Certainement pour viser un public moins averti qui aime bien les applications faciles d’utilisation et attrayantes.

 

 

C#, Silverlight, Visual Studio 2010

L'un des points de faiblesses de silverlight 3.0 comparé a ses concurents était de ne pas povoir accéder a ses fichiers locaux directement a partir de l'application silverlight 3.0. Désormais, Grâce à la nouvelle version de silverlight (silverlight 4.0) tout cela est maintenant possible.

Cette nouveauté se résume à une méthode : « Environment.GetFolderPath » qui nous permet de récupérer le répertoire du chemin désiré. Dans le cas opposé, si l’on veut énumérer tous les fichiers contenus dans un répertoire, nous avons la méthode :  « Directory.EnumerateFiles »

using System; using System.Collections.Generic; using [...]   namespace APILocalFiles {     public partial class MainPage : UserControl     {         public MainPage()         {             InitializeComponent();         }           private void OnEnumerateLocaFiles(object sender, RoutedEventArgs e)         {             List<string> photosInFolder = new List<string>();               var photos = Directory.EnumerateFiles(Environment.GetFolderPath(Environment.SpecialFolder.MyPictures));               foreach (var item in photos)             {                 photosInFolder.Add(item);             }               lbPhotos.ItemsSource = photosInFolder;         }     } }

Ici il est créé une méthode permettant d’énumérer tous les fichiers et dossiers contenus dans le répertoire indiqué en paramètre.

La boucle foreach permet ici d’ajouter chaque élément énuméré à la liste de chaine de caractère créée au début.

Après compilation on obtient la fenêtre ci-dessus.

Cependant si l’on clique sur « Enumerate Local Files » Visual Studio nous sort une exception présentée ci-dessous. En effet, pour que cette nouvelle API fonctionne correctement, il faut absolument que l’application s’exécute en dehors du navigateur et en mode plus de privilège.

Pour palier à cette exception il suffit d’aller dans les propriétés de l’application silverlight et cocher les lignes suivantes :

            -« Enable running application out of browser »

-« Require elevated trust when running outside the browser » après avoir cliqué sur « Out-of-Browser Settings… »

Ensuite on relance l’application et là, à l’aide d’un clic droit, on installe l’application sur l’ordinateur.

En effet, l'accés aux fichiers locaux se fait en Out Of Browser (OOB)

De plus, si par exemple nous voulons implanter cette fonctionalité dans une application utilisée par de nombreuses personnes, ces dernieres devront toutes installer cette application en "local" sur leurs machines. Ce dernier point peut à la fois etre un avantage et un inconvénient.

Une fois cette application installée, si l’on clique sur « enumerate files » la liste des dossiers et documents contenus dans le répertoire est affichée, comme cela nous est détaillé ci-dessous :

Nous pouvons dés-lors affirmer que par cette nouveauté ainsi que bien d'autres non citées ici, silverlight 4.0 exprime bien sa volonté de revenir au contact de ses principaux concurents tel que le flash.

Bien évidemment a l'heure où est écrit cet article la version 4 de Silverlight n'est aps une réelle nouveauté. De plus avec la sortie de la version 5 de HTML, cette derniere tend à faire oulier silverlight.

Attendons de voir la version 5 de Silverlight qui s'annoce assez intérésente :)

 

C#, Silverlight, Visual Studio 2010

 

Introduction :

Cet article va vous apprendre comment créer une visionneuse d’image en VB.NET. Pour ceux qui ne sauraient pas ce qu’est une visionneuse d’image, voici celle de Windows. A la fin de ce TP nous devrions avoir un résultat similaire.

Objectifs de cet article :

-          Créer des contrôles et des évènements

-          Créer un menu

-          Lister les fichiers présents dans un dossier

-          Imprimer une image

-          Copier une image dans le presse-papier

-          Supprimer un fichier

-          Faire pivoter une image

 

Première étape : Création du projet

La première étape consiste à créer un nouveau projet Visual Basic - Windows Form Application. Donnez-lui le nom de votre choix, moi j’ai choisi ImageViewer. Ce projet a été réalisé à l’aide de Visual Studio 2010 Ultimate.

Vous devriez voir un onglet appelé Form1.vb [Design]. A l’intérieur se trouve une fenêtre nommée Form1. Dans ses propriétés changez les attributs Name et Text pour ImageViewer et mettez l’attribut Size à 800 ; 600.

Deuxième étape : Création des contrôles

Pour créer un menu, utilisez le MenuStrip de la boîte à outils et insérez le dans la fenêtre. Créez le sous-menu Fichier qui contient les options : Ouvrir,  Copier, Imprimer, Supprimer et Quitter.

Ensuite il faut ajouter des boutons. Il en faut six : Suivant, Précédent, Diaporama, Rotation Gauche, Rotation Droite et Supprimer. Tous les boutons sont placés dans un Panel. Mettez la propriété Visible du Panel à False pour éviter que les boutons soient visibles lorsqu’aucune image n’est affichée dans la PictureBox Il faut également ajouter une PictureBox au milieu de la fenêtre. La propriété SizeMode de la PictureBox doit être à StretchImage.

Pour mettre des images dans les boutons, rendez-vous dans les Propriétés du projet (Projet, Propriétés de ImageViewer) puis dans Ressources. Ajoutez-y les images que vous souhaitez utiliser. Celles qui apparaissent sur les captures d’écran proviennent d’IconFinder. Ensuite il suffit de modifier la propriété Image des boutons.

Pour afficher des informations sur les boutons il faut créer un ToolTip et modifier la propriété « Tooltip sur NomDeVotreTooltip » de chacun des boutons.

Troisième étape : Création d’une classe Viewer

Une fois tous les contrôles créés, ajoutez une Classe au projet. Pour cela, clic droit sur le projet, Ajouter, Classe. Appelez cette classe Viewer et ajoutez-y deux régions, une pour les attributs de la classe et l’autre pour les méthodes. Les régions ne sont en aucun cas nécessaires mais elles permettent de mieux organiser le code.

Vous devriez avoir quelque chose de ce type :

Public Class Viewer

#Region “Attributs”
#End Region

#Region “Méthodes”
#End Region

End Class

Cette classe contient deux attributs : tabImages qui est une liste contenant des liens absolus vers les images présentes dans le même dossier que l’image ouverte et current qui contient le numéro de l’image affichée.

#Region “Attributs”

Private tabImages As New ArrayList 'Liste contenant un lien absolu vers toutes les images présentes dans le dossier

                Private current As Integer 'Numéro de l'image affichée
#End Region

 

La fonction GetFiles :

Une fonction Getfiles existe déjà mais ne permet pas de lister les fichiers d’un répertoire en fonction de plusieurs extensions.

Public Function GetFiles(ByVal repertoire As String, ByVal extensions As String()) As String()

        Dim fichiers As List(Of String) = New List(Of String)()

        For Each extension As String In extensions

fichiers.AddRange(IO.Directory.GetFiles(repertoire, extension, IO.SearchOption.TopDirectoryOnly))

        Next

        Return fichiers.ToArray()

    End Function

 

 

Cette fonction accepte plusieurs paramètres : une chaine de caractères indiquant le chemin vers le répertoire dont veut lister les fichiers ainsi qu’un tableau de chaines de caractères. Ce tableau contient la liste des extensions qu’il faut prendre en compte. Elle renvoi un tableau de chaines de caractères qui sont les noms des fichiers dont les extensions correspondent à celles présentes dans le tableau. Pour chaque extension du tableau cette fonction va appeler la méthode GetFiles de la classe Directory.

IO.SearchOption.TopDirectoryOnly signifie que seuls les fichiers présents dans le répertoire actif sont listés et pas ceux des sous-répertoires.

Vous pouvez commenter les fonctions, pour cela ajoutez ''' (3 apostrophes) au dessus de la fonction. Vous devriez voir apparaitre les lignes ci-dessous.

    ''' <summary>

    '''

    ''' </summary>

    ''' <param name="parametre1"></param>

    ''' <param name="parametre2"></param>

    ''' <returns></returns>

    ''' <remarks></remarks>

Il suffit ensuite d’ajouter du texte entre les balises.

 

Le constructeur :

Le constructeur est une méthode qui est appelée au moment où un objet est créé, cette méthode a pour but d’initialiser les attributs de l’objet. Ici, le constructeur ne prendra aucun paramètre.

Sub New()

                For Each image As String In GetFiles(IO.Directory.GetParent(ImageViewer.OpenImage.FileName).FullName,{"*.jpg", "*.jpeg", "*.png", "*.gif", "*.bmp"})

                               tabImages.Add(image)

                Next

                               current = tabImages.IndexOf(ImageViewer.OpenImage.FileName)

                               Afficher_image(current)

End Sub

Le constructeur appelle la fonction GetFiles que vous avez créée plus tôt pour lister tous les fichiers ayant pour extension jpg, jpeg, png, gif ou bmp présents dans le même répertoire que l’image que l’utilisateur décide d’ouvrir. Chaque image du tableau renvoyé par la fonction GetFiles est ajoutée dans tabImages. Current prend pour valeur l’index de l’image ouverte par l’utilisateur.

 

La méthode Afficher_image :

    Public Sub Afficher_image(ByVal num_image As Integer)

        Try

            ImageViewer.PB_Image.Image = Image.FromFile(tabImages(num_image))

            Redim_image()

        Catch

            tabImages.RemoveAt(num_image)

            current += 1

            Afficher_image(current)

        End Try

    End Sub

 

Cette méthode prend un nombre en paramètre et permet d’afficher l’image ayant ce nombre pour index dans tabImages pour ensuite la redimensionner. Si l’application n’arrive pas à ouvrir une image (ce qui peut arriver si l’utilisateur l’a supprimée entre temps) alors elle est retirée de la liste et l’image suivante est affichée et la valeur de current est incrémentée.

ImageViewer est la classe qui contient tous les contrôles et les évènements qui y sont liés. PB_Image est le nom donné à la PictureBox, Image est la propriété qui a pour valeur l’image à afficher.

La méthode Redim_image :

    Public Sub Redim_image()

If ImageViewer.PB_Image.Image.Height <= ImageViewer.PB_Image.MaximumSize.Height And ImageViewer.PB_Image.Image.Width <= ImageViewer.PB_Image.MaximumSize.Width Then 'Si l'image a des dimensions plus petites que la taille maximum de la PictureBox

            ImageViewer.PB_Image.Size = ImageViewer.PB_Image.Image.Size

        Else

ImageViewer.PB_Image.Width = (ImageViewer.PB_Image.Image.Width * ImageViewer.PB_Image.MaximumSize.Height) / ImageViewer.PB_Image.Image.Height

 

ImageViewer.PB_Image.Height = (ImageViewer.PB_Image.Image.Height * ImageViewer.PB_Image.MaximumSize.Width) / ImageViewer.PB_Image.Image.Width

        End If 

ImageViewer.PB_Image.SetBounds(((ImageViewer.Width - ImageViewer.PB_Image.Width) / 2), ((ImageViewer.Height - ImageViewer.PB_Image.Height) / 2), ImageViewer.PB_Image.Width, ImageViewer.PB_Image.Height)

    End Sub

Si la hauteur et la largeur de l’image affichée sont inférieures à la hauteur et la largeur maximum de la PictureBox alors les dimensions de la PictureBox prennent celles de l’image pour valeur. Sinon elle est redimensionnée proportionnellement aux dimensions de l’image et aux dimensions maximums de la PictureBox. Une fois redimensionnée, elle est placée au centre de la fenêtre.

 

La méthode Image_suivante :

                Public Sub Image_suivante()

                               If current = (tabImages.Count - 1) Then

                                               Afficher_image(0)

                                               current = 0

                               Else

                                               Afficher_image(current + 1)

                                               current += 1

                               End If

                End Sub

Cette méthode affiche l’image qui se situe après l’image actuelle. Si l’index de l’image actuelle est égal au nombre d’éléments présents dans la liste – 1 (car une liste commence à 0) alors current prend 0 pour valeur sinon sa valeur est augmentée de 1.

 

La méthode Image_precedente :

Public Sub Image_precedente()

                If current = 0 Then

                               Afficher_image(tabImages.Count - 1)

                               current = tabImages.Count - 1

                Else

                               Afficher_image(current - 1)

                               current -= 1

                End If

End Sub

Cette méthode fonctionne sur le même principe que Image_suivante. Si l’index de l’image courante est 0  alors current vaut la taille de la liste - 1, dans le cas contraire il y a décrémentation de la valeur de current.

La méthode Rotation_image :

Public Sub Rotation_image(ByVal sensHoraire As Boolean)

If sensHoraire = False Then

ImageViewer.PB_Image.Image.RotateFlip(RotateFlipType.Rotate270FlipNone) 'Rotation de 90° dans le sens anti-horaire

ElseIf sensHoraire = True Then

ImageViewer.PB_Image.Image.RotateFlip(RotateFlipType.Rotate90FlipNone) ' Rotation de 90° dans le sens horaire

                End If

                Redim_image()

End Sub

Cette méthode prend un Booléen en paramètre. Ce booléen vaut True si la rotation se fait sans le sens horaire et False dans le sens anti-horaire. Après la rotation, l’image est redimensionnée pour qu’elle s’affiche correctement. Si elle n’était pas redimensionnée les proportions ne seraient pas conservées et l’affichage serait donc incorrect.

 

La méthode Supprimer_image :

Public Sub Supprimer_image()

ImageViewer.PB_Image.Image.Dispose()

Try ' Si une image est supprimée on l'enlève de la liste et on affiche la suivante

My.Computer.FileSystem.DeleteFile(tabImages(current), FileIO.UIOption.AllDialogs, FileIO.RecycleOption.SendToRecycleBin)

tabImages.RemoveAt(current)

current += 1

Afficher_image(current)

Catch 'Si l'utilisateur clique sur Annuler cela lève une exception

End Try

End Sub

Cette méthode envoi l’image courante à la corbeille. La boite de dialogue demandant confirmation est affichée. Si l’utilisateur clique sur Non ou ferme la boite de dialogue, une exception est levée, dans ce cas aucune instruction n’est exécutée. Si l’utilisateur clique sur Oui l’image est retirée de la liste et l’image suivante est affichée.

Qutrième étape : Création des évènements

Dans la classe ImageViewer, donc celle qui correspond à notre fenêtre, déclarez un objet de type viewer.

Dim viewer As Viewer

Evènements liés aux éléments du menu :

Ouverture d’une image :

Private Sub Ouvrir_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Ouvrir.Click

OpenImage.Filter = "Images| *.jpg; *.jpeg; *.gif; *.png; *.bmp"

If OpenImage.ShowDialog() = DialogResult.OK Then

viewer = New Viewer()

P_Boutons.Visible = True

End If

End Sub

Un filtre est créé pour qu’on ne puisse ouvrir que des images. Si une image est choisie alors le constructeur de la classe Viewer est appelé et les boutons sont affichés.

Copier une image dans le presse-papier :

Private Sub Copier_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Copier.Click

        If PB_Image.Image IsNot Nothing Then

            Clipboard.SetDataObject(PB_Image.Image)

        End If

End Sub

Si une image est affichée alors elle est placée dans le presse-papier. Elle pourra ensuite être collée dans un autre document.

 

Imprimer une image :

Private Sub Imprimer_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Imprimer.Click

        If PB_Image.Image IsNot Nothing Then

            PrintOptions.Document = Me.PrintImage

            If PrintOptions.ShowDialog() = DialogResult.OK Then

                Try

                    PrintImage.Print()

                Catch

                End Try

            End If

        End If

End Sub

 

Private Sub PrintImage_PrintPage(ByVal sender As System.Object, ByVal e As System.Drawing.Printing.PrintPageEventArgs) Handles PrintImage.PrintPage

        e.Graphics.DrawImage(PB_Image.Image, PB_Image.Bounds)

End Sub

 

Ces évènements sont appelés lorsque l’utilisateur veut imprimer une image. Créez deux autres contrôles dans le projet : un PrintDocument, appelé PrintImage et un PrintDialog, appelé PrintOptions. Si une image est affichée, alors le document à imprimer est cette image. Si l’impression est annulée ou ne fonctionne pas, une exception est levée.

Supprimer une image :

Private Sub Supprimer_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Supprimer.Click

        If PB_Image.Image IsNot Nothing Then

            viewer.Supprimer_image()

        End If

End Sub

Si une image est affichée alors on appelle la méthode Supprimer_image.

Quitter :

Private Sub Quitter_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Quitter.Click

        End

End Sub

Cet évènement arrête l’exécution de l’application et ferme la fenêtre.

Evènements liés aux boutons :

Le bouton Précédent :

Private Sub BT_Precedent_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BT_Precedent.Click

        viewer.Image_precedente()

End Sub

Lorsqu’il y a un clic sur ce bouton, la méthode Image_precedente est appelée.

 

Le bouton Diaporama :

Private Sub BT_Diaporama_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BT_Diaporama.Click

        Me.FormBorderStyle = Windows.Forms.FormBorderStyle.None

        Me.TopMost = True

        Me.WindowState = FormWindowState.Maximized

        P_Boutons.Hide()

        M_Menu.Hide()

        Cursor.Hide()

        Me.Focus()

        timer.Enabled = True

End Sub

 

Private Sub timer_Tick(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles timer.Tick

        viewer.Image_suivante()

End Sub

 

Shadows Sub KeyDown(ByVal sender As System.Object, ByVal e As System.Windows.Forms.KeyEventArgs) Handles MyBase.KeyDown

        If Me.WindowState = FormWindowState.Maximized Then

            If e.KeyCode = Keys.Escape Then

                Me.FormBorderStyle = Windows.Forms.FormBorderStyle.Sizable

                Me.WindowState = FormWindowState.Normal

                Me.TopMost = False

                P_Boutons.Show()

                M_Menu.Show()

                Cursor.Show()

                timer.Enabled = False

            End If

        End If

End Sub

Pour gérer le diaporama, créez un nouveau contrôle de type Timer. Mettez ses propriété Enabled à false et Interval à 5000ms. Une fois le timer déclenché il va appeler la méthode Image_suivante toutes les cinq secondes.

Lorsqu’il y a un clic sur le bouton Diaporama, les bordures de la fenêtre sont masquées, la fenêtre est affichée au premier plan et en plein écran. Les boutons, le curseur et le menu sont cachés et le timer est déclenché.

Pour arrêter le diaporama, ajoutez un évènement de type KeyDown sur la fenêtre. Si la fenêtre est en plein écran et qu’’il y a un appuie sur la touche Echap alors la fenêtre est remise dans son état précédent ; c’est-à-dire mode fenêtré avec bordures,  réaffichage des boutons, du curseur et du menu puis on arrêt du timer.

Le bouton Suivant :

Private Sub BT_Suivant_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BT_Suivant.Click

        viewer.Image_suivante()

End Sub

Lorsqu’on clique sur ce bouton, la méthode Image_suivante est appelée.

 

Le bouton Rotation Gauche :

Private Sub BT_Gauche_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BT_Gauche.Click

        viewer.Rotation_image(False)

End Sub

Un clic sur ce bouton appelle la méthode Rotation_image avec False en paramètre, ce qui veut dire que la rotation se fera dans le sens anti-horaire.

Le bouton Rotation Droite :

Private Sub BT_Droite_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BT_Droite.Click

        viewer.Rotation_image(True)

End Sub

Un clic sur ce bouton appelle la méthode Rotation_image avec True en paramètre, ce qui veut dire que la rotation se fera dans le sens horaire.

Le bouton Supprimer :

Private Sub BT_Supprimer_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BT_Supprimer.Click

        viewer.Supprimer_image()

End Sub

Ce bouton appelle la méthode Supprimer_Image.

Redimensionnement de la fenêtre :

Private Sub ImageViewer_SizeChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.SizeChanged

        PB_Image.MaximumSize = New Size((Me.Width), (Me.Height - 80))

        If PB_Image.Image IsNot Nothing Then

            viewer.Redim_image()

        End If

End Sub

Ajoutez un évènement SizeChanged sur la fenêtre. Lorsque la taille de la fenêtre change, les dimensions maximum de la PictureBox changent et si une image est affichée elle est redimensionnée.

Me.Height – 80 Permet de ne pas afficher une image au dessus des boutons ou du menu.

vb.net, Visual Studio 2010

Introduction

Lorsque vous travaillez avec des données, vous aurez souvent besoin de filtrer les résultats en fonction de certains critères. Typiquement, cela se fait en acceptant la saisie d'un utilisateur et en utilisant cette entrée pour former une requête SQL. Par exemple, une personne pourrai avoir de voir toutes les commandes entre des dates spécifiques.

Une autre requête pourrait être simplement de récupérer des champs suivant l’ID d’un enregistrement.

Comme vous le savez, la requête SQL assignée à un objet SqlCommand est simplement une chaîne.

Donc, si vous souhaitez filtrer une requête, vous pouvez créer la chaîne dynamique, mais cela est risqué car la requête n’est pas protégée.

 

Voici un mauvais exemple de filtrage d'une requête.

Ne jamais créer une requête de cette façon! La variable d'entrée,  idTable, est généralement récupérée à partir d'un contrôle TextBox soit sur un formulaire Windows ou une page Web. Tout ce qui est placé dans le contrôle TextBox sera mis en idTable et ajouté à votre chaîne SQL. Cette situation peut inciter un pirate à remplacer cette chaîne par un code malveillant.

Au lieu de construire dynamiquement une chaîne, comme le montre le mauvais exemple ci-dessus, utilisez les requêtes paramétrées.

Tout ce qui est placé dans un paramètre sera traité et ne fait pas partie de l'instruction SQL, ce qui rend votre application beaucoup plus sûre.

L'utilisation de requêtes paramétrées est un processus en trois étapes:

   1. Construire la chaîne de commande SqlCommand avec des paramètres.
   2. Déclarez un objet SqlParameter en lui attribuant une valeurs.
   3. Assignez l'objet SqlParameter à la propriété de l'objet SqlCommand.

Les sections suivantes vous guident étape par étape à travers ce processus.

 

La préparation d'un objet SqlCommand pour les paramètres

La première étape dans l'utilisation de paramètres dans les requêtes SQL est de construire une chaîne de commande contenant des espaces réservés de paramètres. Ces espaces réservés sont remplis avec des valeurs de paramètre réel quand la SqlCommand est exécuté.

La syntaxe correcte d'un paramètre est d'utiliser un préfixe symbole "@" sur le nom du paramètre comme indiqué ci-dessous:

 

Dans le constructeur de SqlCommand ci-dessus, le premier argument contient une déclaration de paramètre, @id. Cet exemple utilise un paramètre, mais vous pouvez avoir autant de paramètres que nécessaire pour personnaliser la requête. Chaque paramètre correspondant à un objet SqlParameter qui doit être affectés à cet objet SqlCommand.

 

Déclarer un objet SqlParameter

Chaque paramètre dans une instruction SQL doit être défini. Tel est l'objet du type SqlParameter. Votre code doit définir une instance de SqlParameter pour chaque paramètre de commande d'un objet SqlCommand de SQL. Le code suivant définit un paramètre pour le paramètre @id de la section précédente:

 

Notez que la propriété ParameterName de l'instance SqlParameter doit être écrite  exactement comme le paramètre qui est utilisé dans la chaîne de commande SQL SqlCommand. Vous devez également spécifier une valeur pour la commande. Lorsque l'objet SqlCommand s'exécute, le paramètre sera remplacé par cette valeur.

 

Associer un objet SqlParameter avec un objet SqlCommand

Pour chaque paramètre défini dans la chaîne de commande de l’objet SqlCommand, vous devez définir un SqlParameter.

Vous devez également ajouter à l'objet SqlCommand tous les SqlParameter en attribuant l'instance SqlParameter à la propriété Parameters de l'objet SqlCommand.

 Le code suivant montre comment faire:

L'instance SqlParameter est l'argument de la méthode Add de la propriété Parameters de l'objet SqlCommand ci-dessus.

Vous devez ajouter un unique SqlParameter pour chaque paramètre défini dans la chaîne de l'objet SqlCommand de commande SQL.

 

On met tout ensemble.

Résumé :

Vous devez utiliser des paramètres pour filtrer les requêtes d'une manière sûre, un très bon moyen pour éviter les injections SQL.

Le processus de d’utilisation du paramètre comporte trois étapes:

-définir le paramètre dans la chaîne de commande SqlCommand.

-déclarer l'objet SqlParameter avec des propriétés applicables.

-Affecter l'objet SqlParameter à l'objet SqlCommand.

Lorsque le SqlCommand est exécuté, les paramètres seront remplacés par les valeurs spécifiées par l'objet SqlParameter.

 

Voilà vous savez tout sur les requêtes paramétrés ! Écouter

Lire phonétiquement

 

ADO.NET, C# sql, injections, requêtes paramétrées, ado, base de données

C#

 object styleHeading1 = "Heading1";

 

oPara1.Range.set_Style(ref styleHeading1);

Le programmeur peut ajouter du texte à l'alinéa :

 

 oPara1.Range.Text = "Create a New Report";

Si en outre les paragraphes doivent être ajoutés puis un décompte final est nécessaire :

 oPara1.Range.InsertParagraphAfter();

 

Cette déclaration assure que l'ajout de nouveaux paragraphes ne va pas écraser l'existant. Tout nouveau  paragraphe est  ajouté  exactement de la même manière :

 

 word.Paragraph oPara2;

oPara2 = oDoc.Paragraphs.Add(ref oMissing);

oPara2.Range.text = "This is my first paragraph.";

oPara2.Range.InsertParagraphAfter();

Word.Paragraph oPara3;

oPara3 = oDoc.Paragraphs.Add(ref oMissing);

oPara3.Range.text = "This is my second paragraph.";

oPara3.Range.InsertParagraphAfter();

Dans l'exemple ci-dessus les nouveaux paragraphes auront  juste le formatage par défaut.

 

 

 

Enregistrement d'un document Microsoft Word avec C #

Une fois que le document contient toutes les informations nécessaires,  il peut être enregistré :

object filename = "C:\\Reports\\daily_report.doc";

oDoc.SaveAs (ref filename,

ref oMissing, ref oMissing,

ref oMissing, ref oMissing,

ref oMissing, ref oMissing,

ref oMissing, ref oMissing,

ref oMissing, ref oMissing);

 

 

Toutefois, il convient de noter que cette opération écrase un fichier existant du même nom.

Fermeture d'un document Microsoft Word

Enfin, le document peut être fermé :

 

oDoc.Close( ref oMissing, ref oMissing, ref oMissing);

 

        oWord.Quit(ref oMissing, ref oMissing, ref oMissing);

        oWord = null;

 

 

 Vous libérez toute la mémoire utilisée.

À ce stade, le compilateur peut vous donner un avertissement ambigu.  C'est parce qu'il y a  les méthodes d'abandon et d’événements. Toutefois, le compilateur va résoudre l'ambiguïté elle-même et l'application fonctionnera comme prévu.

A la fin du processus de l'application on produit un nouveau document Microsoft Word qui est entièrement formaté et contient les informations prévues par le programmeur.

 

 

 

C#

Le nouvel OS mobile de Microsoft, Windows Phone 7, nous permet via l’écran tactile capacitif de gérer plusieurs points d’appuis. Nous allons voir dans cet article comment gérer cet écran au sein d’ XNA 4 et en faire une utilisation basique de détection de position.

Nous allons avoir besoin des logiciels et SDK suivants :

XNA Game Studio 4

Visual Studio 2010 + Windows Phone Tools

Maintenant voyons la marche à suivre pour la gestion du Touch. Tout d’abord, nous devons nous assurer que le Touch est disponible pour « lire » nos entrées dans la boucle Update.

 

TouchPanelCapabilities touchCap = TouchPanel.GetCapabilities();
 
             if (touchCap.IsConnected)
             {..}
 

Et l’on récupère l’état actuel du périphérique.

TouchCollection touches = TouchPanel.GetState();

 

On obtient donc une collection de « touches » (Points de pression) qui contient pour chaque touche ses coordonnées ainsi que l’état. Concernant ces états, il y a 4 possibilités :

-Invalid : Problème de reconnaissance
-Moved : La position a été mise à jour ou la position ne change pas
-Pressed : Il s’agit d’une nouvelle position
-Released : La position n’existe plus

 

Passons maintenant à la partie détection d’un appui sur l’écran.

if (touches.Count >= 1)
{

touchposition = (touches[0].Position);
}
 

Ici, on test si il y a au moins un point de pression de répertorier. Nous utilisons touchposition, qui est un Vector2 pour récupérer les coordonnées X et Y du point de pression. Attention ici il s’agit du point 0, l’écran du Windows Phone 7 peut gérer jusqu’à 4 points de pression. Il faudra donc penser lors du développement à tester les 4 points de pression. Ici à cause de l’émulateur seul le clic de la souris permet de simuler un point de pression. (Le nombre de point de pression possibles peut être vérifié via touchCap.MaximumTouchCount) .

Maintenant que nous avons ce Vector2 touchposition, nous pouvons l’utiliser comme nous voulons et très simplement. Par exemple pour afficher les coordonnées du point de pression.

Dans la boucle Draw, nous allons donc écrire les coordonnées du point de pression.

spriteBatch.Begin();         
string positionX = string.Format("X : {0}", touchposition.X);
spriteBatch.DrawString(font1, positionX,new Vector2(50,380), Color.White);
string positionY = string.Format("Y : {0}", touchposition.Y);
spriteBatch.DrawString(font1, positionY,new Vector2(50,420), Color.White);
spriteBatch.End();
 

font1 est un SpriteFont que j’ai ajouté au projet, il correspond à la police Segoe UI Mono. Celle utilisée par défaut par Windows Phone 7.

 

Faisons un petit résumé du code, commençons par la boucle Update :

TouchPanelCapabilities touchCap = TouchPanel.GetCapabilities();
if (touchCap.IsConnected)
{
TouchCollection touches = TouchPanel.GetState();


if (touches.Count >= 1)
{
touchposition = (touches[0].Position);
}
}
 

Et la boucle Draw pour dessiner notre résultat :

GraphicsDevice.Clear(Color.Black);
spriteBatch.Begin();
string positionX = string.Format("X : {0}", touchposition.X);
spriteBatch.DrawString(font1, positionX,new Vector2(50,380), Color.White);
string positionY = string.Format("Y : {0}", touchposition.Y);
spriteBatch.DrawString(font1, positionY,new Vector2(50,420), Color.White);
spriteBatch.End();
 

Voyons maintenant en image ce que l’on vient de réaliser :

Premier screen : Lancement de l’application, pas d’appui coordonnées = 0
Second screen : Simulation d’un point de pression via un clic souris, mise à jour des coordonnées
Troisième screen : Autre clic, changement des coordonnées

Maintenant c’est à votre tour d’utiliser le Touch. A vos Visual Studio !

C#, Visual Studio 2010, Windows phone 7, XNA .net, visual studio 2010, wp7, xna

 

Une des nouveautés parmi les nombreuses disponibles dans  Silverlight 3 & 4 est la possibilité de créer des applications utilisable hors-navigateur (out-of-browser), peut-être un nouveau concurrent pour Adobe-Air.

Pour mettre en place cet outil, rien de plus simple et  en seulement quelques clic, pour ce faire suivez les instructions ci-dessous :

1-Mise en place du mode Offline.

Commencez par faire un clic droit sur votre projet puis cliquez sur propriété (Properties)

 

 

Une fenêtre s’ouvre cochez la case « Enable running application out of the browser »

Puis cliquez sur le bouton  « Out-of-browser Settings ... »

 

 

Une nouvelle fenêtre s’ouvre, cette fois nous allons renseigner le titre, une description, la taille de la fenêtre de l’application offline ainsi que les différentes icônes de différentes tailles qui nous permettront de personnaliser notre application offline.

 

 

On finit par cliquer sur OK puis on exécute l’application.

 

2) Installation de l’application :

Pour installer l’application il existe 2 façons différentes, en faisant un simple clic droit puis cliquer sur « Installer "le nom de votre application" sur cet ordinateur… »

 

 

 

Ou bien en créant un bouton et en ajoutant cette ligne au clic « Application.Current.Install() ; »

Une fois la méthode choisi, cochez les 2 cases « Menu démarrer » et/ou « Bureau » pour que l’application puisse créer des raccourcis dans les endroits spécifiés.

 

 

 

Finalement nous obtenons la même application en mode offline, avec la taille et titre spécifié, vous pouvez aussi remarquer que toutes les icônes que nous avons ajoutés précédemment ont été utilisées à différentes étapes de l’installation de l’application.

 

3) Gestion du mode online/offline (code behind):

Deux autres petites choses à savoir :
Pour tester la connectivité réseau, il suffit de tester la valeur de retour de la méthode suivante :

NetworkInterface.GetIsNetworkAvailable()

L’événement NetworkChange.NetworkAddressChanged est déclenché lorsque la connectivité change.

Deuxième chose:

Pour tester si l’application a été lancée en mode Offline, il suffit de tester la propriété suivante :

Application.Current.RunningOffline

Ou

Application.Current.ExecutionState

Qui donne plus de détails comme nous allons voir juste après.

 

Gestion des mises à jour avec une application Offline

Lorsque l’application est lancée en mode Offline et qu’une connectivité réseau est disponible alors avec une simple requête HTTP, il regarde si le fichier .xap disponible à l’Uri original a été modifié.

En cas de modification, l’ExecutionState de l’application est assigné à la valeur DetachedUpdatesAvailable.

 

ExecutionStateChanged += new EventHandler(App_ExecutionStateChanged);   void App_ExecutionStateChanged(object sender, EventArgs e) {     if(this.ExecutionState == ExecutionStates.DetachedUpdatesAvailable)     {          MessageBox.Show("Une nouvelle  mise à jour de l'application est disponible, elle sera disponible à son prochain démarrage");     } }

 

Voilà, maintenant le mode "Out Of Browser" n'a plus aucun secret pour vous !

 

 

C#, Silverlight silverlight, mode offline, application, hors ligne

C# - Les attributs

 

 

I)                   Rappel sur les attributs

Les attributs apportent deux fonctionnalités au développeur C#.

D’abord, il sert à donner des informations au compilateur. Par exemple, l’attribut [CLSCompliant] demande au compilateur de vérifier que la fonction est bien conforme à la norme CLS, ce qui lui permettra d’être appelé par n’importe quel langage compatible avec le Framework.

Egalement, les attributs permettent d’annoter des classes, des méthodes, des propriétés, des arguments… Annoter signifie ici associer des valeurs de manière descriptive, donc sans devoir écrire du code spécial. Ces annotations seront  enregistrées dans la DLL de la classe, parmi les métadonnées qui décrivent la DLL et il suffira de quelques lignes de code à un programme utilisateur pour qu’il puisse retrouver ces annotations.

Les attributs sont très utilisés par les développeurs de composant. Ils leur permettent notamment d’annoter leurs composants d’informations utiles pour les outils de développements.

Certains sont prédéfinis, mais on a également la possibilité de créer et de personnaliser nos attributs.

 

 

II)                Attributs prédéfinis

Nous allons voir ici l’utilisation d’un attribut prédéfini par la CLR (Common Language Runtime) .NET. Il s’agit de l’attribut [Obsolete]. Il permet d’indiquer, lors de la compilation, qu’une classe, une méthode ou une propriété ne doit plus être utilisée. Il accepte deux arguments, le premier est un message et le second est une valeur booléenne. Si cette valeur booléenne est passée à false, le compilateur retourne un message d’avertissement, sinon, à true, il retourne une erreur.

Exemple d’utilisation de [Obsolete] :

 

III)       Attributs personnalisés

Les attributs personnalisés doivent être des classes publiques et initialisés à l’aide de constructeurs. Chaque attribut doit avoir au moins un constructeur et on peut également surcharger le constructeur afin de permettre à l’attribut de s’appliquer à la classe de plusieurs façons différentes.

Pour créer un attribut personnalisé, nous devons d’abords dériver la classe Attribute, puis définir la cible de notre attribut en utilisant l’attribut [AttributeUsage]. [AttributeUsage] prend en argument AttributeTargets.All, .Class, .Constructor, .Field, .Method, ou .Property pour spécifier notre cible. On a également la possibilité de spécifier plusieurs cibles, pour cela, il suffit de séparer les arguments de |.

Exemple :

 

Ici, on créer un attribut [Aide] et on l’applique à une classe Employee.

Voyons maintenant comment le programme utilisateur va récupérer ces annotations. Il utilise la réflexion.

Qu’est ce que la réflexion ? La réflexion fourni des objets qui encapsulent les assemblages, modules et types. C'est le processus par lequel un programme peut inspecter les informations de métadonnées dynamiquement à l'aide de l'API de réflexion

D’abord, il faut ajouter  une référence à notre DLL, ici HelpClass.dll. Aussi, une référence vers System.Reflection est bien évidemment nécessaire. Nous allons utiliser la classe Type (au travers de typeof qui renvoie un objet de la classe Type) et la classe MethodInfo de l’espace de nom System.Reflection.

On récupère dans un premier temps l’Aide de la classe Employee :

Puis l’aide de la méthode AfficheInfo :

C#