Cours VB.NET

Date de mise à jour : 05/12/2010

X-E. Modifier le curseur, gérer la souris
X-E-1. Apparence du curseur
X-E-2. Curseur sur un contrôle
X-E-3. La souris
X-E-4. Exemples
X-F. Lancer une autre application, afficher une page Web
X-F-1. L'ancienne méthode VisualBasic toujours valable : Shell
X-F-2. On peut utiliser la Classe 'Process' du Framework
X-G. Dessiner
X-G-1. Sur quoi dessiner ?
X-G-2. Comment dessiner ?
X-G-3. Travailler sur un Objet Image
X-G-4. Comment voir un Graphics ?
X-G-5. Un exemple : Afficher un texte en 3D
X-G-6. Espace de noms
X-G-7. Programme simple de dessin
X-G-8. Faire un graphique
X-H. Imprimer
X-H-1. Avec PrintDocument
X-H-1-a. Imprimer 'Hello' avec le composant 'PrintDocument'
X-H-1-a-i. Imprimer un dessin
X-H-1-a-ii. Afficher un Message Box indiquant 'Fin d'impression'
X-H-1-b. Même programme : Imprimer 'Hello' mais avec la Classe PrintDocument
X-H-1-b-i. Comment choisir l'imprimante ?
X-H-1-b-ii. Comment modifier la page à imprimer ?
X-H-1-c. Prévisualisation de la page à imprimer ?
X-H-1-d. Construction d'une application d'impression complexe
X-H-1-e. Propriétés du 'PrintDocument'
X-H-1-f. Imprime le formulaire en cours
X-H-1-g. Imprime un contrôle DataGrid
X-H-2. Imprimer comme en VB6 avec un objet 'Printer'

X-E. Modifier le curseur, gérer la souris

Comment modifier l'apparence du curseur?

Un curseur est une petite image dont l'emplacement à l'écran est contrôlé par la souris, un stylet ou un trackball. Quand l'utilisateur déplace la souris, le système d'exploitation déplace le curseur.

Différentes formes de curseur sont utilisées pour informer l'utilisateur de l'action que va avoir la souris.

X-E-1. Apparence du curseur

Pour modifier l'aspect du curseur il faut modifier l'objet Cursor.Current; l'énumération Cursors contient les différents curseurs disponibles:


System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.WaitCursor

ou plus simplement pour afficher le sablier:


Cursor.Current = Cursors.WaitCursor

Pour revenir au curseur normal:


Cursor.Current = Cursors.Default

Comme d'habitude il suffit de taper Cursors. pour voir la liste des curseurs.

Voici les principaux curseurs:

Le curseur peut disparaître et être de nouveau affiché par Hide et Show.

Les fichiers curseur sont des .Cur ou des .Ico ; pour 'charger' le curseur personnalisé:


Button1.Cursor = New Cursor("MyCurseur.cur")

X-E-2. Curseur sur un contrôle

Un contrôle dans une fenêtre possède une propriété Cursor; en mode design, si je donne une valeur autre que celle par défaut, CursorWait par exemple, cela modifie le curseur quand la souris passe au dessus de l'objet (cela met un sablier dans notre exemple).


Button1.Cursor = Cursors.WaitCursor

X-E-3. La souris

Pour tester si une souris est branchée:(Ce qui est habituel).


SystemInformation.MousePresent  ' retourne True

MouseButtons retourne le nombre de boutons, MouseWheelPresent indique s'il y a une molette.

Chaque contrôle ou formulaire possède des procédures évènements déclenchées par la souris.

MouseEnter : s'exécute lors de l'arrivée de la souris sur un contrôle

MouseLeave :s'exécute lors de la sortie de la souris d'un contrôle

Plus important:

MouseUp se produit lorsque l'utilisateur lâche sur le bouton de la souris

MouseDown se produit lorsque l'utilisateur appuie sur le bouton de la souris

le déplacement de la souris exécute:

MouseMove se produit lorsque l'utilisateur déplace le pointeur de la souris

Un paramètre e de type MouseEventsArgs est alors disponible pour les 3 évènements.

Exemple:

La procédure évènement se produit quand l'utilisateur appuie sur le bouton de la souris.


Private Sub Form1_MouseDown(ByVal sender As System.Object, ByVal e As System.Windows.Forms.MouseEventArgs) _ 
Handles MyBase.MouseDown

..

End Sub

Le paramètre e de type MouseEventsArgs permet de connaître la position de la souris et l'état des boutons:

e.X et e.Y contiennent les coordonnées de la souris dans le contrôle en cours.

Attention ce sont bien les coordonnées du contrôle alors que dans les opérations de drag and drop ce sont par contre les coordonnées 'écran' qui sont utilisées, il faudra les transformer en coordonnées 'contrôl' avec PointToClient : voir le chapitre sur les coordonnées.

e.Button() retourne le bouton qui a été enfoncé.


 If e.Button()=MouseButtons.Left Then..

e.Click() retourne le nombre de Click

e.Delta() retourne le nombre de cran de la molette souris.

Si la souris n'est pas sur le contrôle et que l'on veut quand même récupérer les évènements de la souris sur ce contrôle, il faut mettre la propriété Capture de ce contrôle à True.

Bien sur les évènements les plus utilisés sont Click et DoubleClick.
Certains controles n'ont pas tous les évènements: Les boutons n'ont pas de DoubleClick.

X-E-4. Exemples

Exemple 1 :

Dans un programme de dessin, quand l'utilisateur enfonce le bouton gauche de la souris, on peut récupérer les coordonnées du point ou se trouve la souris.


Private Sub PictureBox1_MouseDown(ByVal sender As Object, ByVal e As System.Windows.Forms.MouseEventArgs) Handles PictureBox1.MouseDown

Dim NewPoint As New Point(e.X, e.Y)

End Sub

Pour voir un exemple complet de dessin, regarder Programme simple de Dessin

Exemple 2: afficher dans une 'bulle' le numéro d'index de l'élément survolé dans une listbox:

Dans MouseMove les coordonnées de la souris permettent de déterminer l'index survolé grâce à IndexFromPoint. L'index est affiché dans un ToolTip.


Private Sub ListBox1_MouseMove(ByVal sender As Object, ByVal e As System.Windows.Forms.MouseEventArgs) 
_Handles ListBox1.MouseMove

ToolTip1.SetToolTip(ListBox1, "Index:"& CType(ListBox1.IndexFromPoint(e.X, e.Y), String))

End Sub

la propriété IndexFromPoint n'existe pas pour les combos.

Voir aussi la page sur le Drag and Drop.

X-F. Lancer une autre application, afficher une page Web

Comment lancer une autre application, un autre programme ?

X-F-1. L'ancienne méthode VisualBasic toujours valable : Shell

Shell lance un programme exécutable.


Id=Shell (NomdeProgramme)    'lance l'application NomdeProgramme

on peut utiliser aussi:


Id=Shell( NomdeProgramme, TypedeFenetre, Wait, TimeOut)

TypedeFenêtre utilise l'énumération AppWinStyle pour définir le type de fenêtre de l'application lancée: AppWinStyle.MaximizedFocus ouvre par exemple l'application en plein écran.

Si vous souhaitez attendre la fin du programme avant de continuer, vous devez définir Wait à True.

TimeOut est le nombre de millisecondes à attendre pour la fin du programme si Wait est True.

Exemple:


ID = Shell("""C:\Program Files\MonFichier.exe"" -a -q", , True, 100000)

Dans une chaîne une paire de guillemets doubles adjacents ("") est interprétée comme un caractère de guillemet double dans la chaîne. Ainsi, l'exemple précédent présente la chaîne suivante à la fonction Shell :
"C:\Program Files\MonFichier.exe" -a -q

La fonction AppActivate rend active l'application ou la fenêtre définie par son nom ou son Id (Numéro indentificateur).


Dim ID As Integer

On peut utiliser:


AppActivate("Untitled - Notepad")


ID = Shell(NOTEPAD.EXE", AppWinStyle.MinimizedNoFocus)
AppActivate(ID)

X-F-2. On peut utiliser la Classe 'Process' du Framework

La Classe Process fournit l'accès à des processus locaux ainsi que distants, et vous permet de démarrer et d'arrêter des processus système locaux.

Classe de nom à importer :Imports System.Diagnostics

On peut instancier un Process


Dim monProcess As New Process()

Ensuite il faut fournir à la classe fille StartInfo les informations nécessaires au démarrage.


monProcess.StartInfo.FileName = "MyFile.doc"
monProcess.StartInfo.Verb = "Print"
monProcess.StartInfo.CreateNoWindow = True

Enfin on lance le process/


monProcess.Start()

Noter la puissance de cette classe: on donne le nom du document et VB lance l'exécutable correspondant, charge le document, effectue certaines actions.

Dans l'exemple du dessus on ouvre Word on y charge MyFile , on l'imprime, cela sans ouvrir de fenêtre.

On peut utiliser la classe Process en statique (sans instanciation)


Process.Start("IExplore.exe")

Process.Start(MonPathFavori)

ou en une ligne:


Process.Start("IExplore.exe", "http//:developpez.com")

En local on peut afficher un fichier html ou asp


Process.Start("IExplore.exe", "C:\monPath\Fichier.htm")
Process.Start("IExplore.exe", "C:\monPath\Fichier.asp")

On peut enfin utiliser un objet StartInfo


Dim startInfo As New ProcessStartInfo("IExplore.exe")
startInfo.WindowStyle = ProcessWindowStyle.Minimized

Process.Start(startInfo)

startInfo.Arguments = "http//:developpez.com"

Process.Start(startInfo)

Des propriétés du processus en cours permettent de connaître l'Id du processus (Id) les threads, les modules, les Dll ,la mémoire , de connaître le texte de la barre de titre (MainWindowsTitle)..

On peut fermer le processus par Close ou CloseMainWindows

On peut instancier un 'Process' sur une application déjà en cours d'exécution avec GetProcessByName et GetProcessById:


Dim P As Process() = Process.GetProcessesByName("notepad")
 

 ' On peut récupérer le processus courant.
Dim ProcessusCourant As Process = Process.GetCurrentProcess()


' Récupérer toutes les instances de  Notepad qui tournent en local.
Dim localByName As Process() = Process.GetProcessesByName("notepad")
 

' Récupérer tous les processus en cours d'exécution grâce à GetProcesses:
Dim localAll As Process() = Process.GetProcesses()

Processus sur ordinateur distant.

Vous pouvez afficher des données statistiques et des informations sur les processus en cours d'exécution sur des ordinateurs distants, mais vous ne pouvez pas appeler Kill, Start, CloseMainWindows sur ceux-ci.

X-G. Dessiner

Avec GDI+ utilisé par VB.NET, on utilise des Graphics.

Un Graphics est une simple référence à

- une Image ( un BitMap ou un MetaFile).

- la surface de dessin d'un contrôle.

Le Graphics n'est pas le dessin lui même, il "pointe" simplement sur le dessin.

Il faut utiliser le Graphics pour dessiner (des points, lignes, rectangles, ellipses, couleur..) ou y écrire.

-Rectangle permet de définir une zone.

-Pen correspond à un Stylet.

-Font correspond à une police de caractères.

-Brush est une brosse.

X-G-1. Sur quoi dessiner ?

Sur un objet Graphics. Il faut donc définir une référence, un objet Graphics. On peut y associer des objets Image (des BitMap ou des MetaFile)

Pour obtenir un objet Graphics, il y a plusieurs façons:

Soit on instance un objet Graphics.


Dim g as Graphics     'Graphics contient Nothing, je ne peux rien en faire.

Il faut donc y associer un objet Image (un BitMap ou un MetaFile)pour pouvoir travailler dessus.

Pour obtenir un BitMap par exemple, on peut:

Soit créer un objet BitMap vide:


Dim newBitmap As Bitmap = New Bitmap(600, 400) 

Dim g as Graphics = Graphics.FromImage(newBitmap)

Paramètres= taille du BitMap mais il y a plein de surcharges

Soit créer un BitMap à partir d'un fichier sur disque

C'est pratique si on veut modifier une image qui est dans un fichier: on la lit dans un BitMap puis on passe la référence dans l'objet Graphics.


Dim myBitmap as New Bitmap("maPhoto.bmp")    'Charge maPhoto dans le BitMap
Dim g as Graphics = Graphics.FromImage(myBitmap)    'Crée un Graphics et y associe le BitMap

g est un Graphics "pointant" sur l'image lue dans 'maPhoto.bmp' et je peux la modifier dans g.

Attention: le Graphics n'est pas 'visible', pour le voir il faut le mettre dans un composant (un PictureBox par exemple) qui lui sera visible. On verra cela plus bas.

Soit on appelle la méthode CreateGraphics d'un contrôle ou d'un formulaire

On appelle la méthode CreateGraphics d'un contrôle ou d'un formulaire afin d'obtenir une référence à un objet Graphics représentant la surface de dessin de ce contrôle ou de ce formulaire.

Cette méthode est utilisée si vous voulez dessiner sur un formulaire ou un contrôle existant ;


Dim g as Graphics
g = Me.CreateGraphics    'Pour un formulaire

Dim g as Graphics
g = Panel1.CreateGraphics    'Pour un contrôle Panel

On peut ensuite dessiner sur g, cela sera immédiatement visible sur le contrôle ou le formulaire (car g n'est pas un nouvel objet, il contient seulement la référence, le handles, de l'image du contrôle; quand on dessine sur g, en fait, on dessine sur l'image du contrôle).

Il faut quand on n'utilise plus l'objet graphics, utiliser la méthode Dispose pour le libérer.

Soit on récupère la référence de l'objet Graphics argument de l'évènement Paint d'un contrôle.

L'événement Paint des contrôles se déclenche lorsque le contrôle est redessiné, un objet Graphics est fourni comme une valeur de PaintEventArgs.

Pour obtenir une référence à un objet Graphics à partir des PaintEventArgs de l'événement Paint et dessiner:

Déclarez l'objet Graphics
Assignez la variable pour qu'elle référence l'objet Graphics passé dans les PaintEventArgs.
Dessinez dans l'objet Graphics.


Private Sub Form1_Paint(sender As Object, e As PaintEventArgs) Handles _
   MyBase.Paint    'appelle la méthode Paint 'normale'
   
   Dim g As Graphics = e.Graphics 
   ' Dessiner avec g , cela affichera dans la Form1
End Sub

Là aussi c'est la référence à l'objet qui a déclenché Paint (Form1 ici), si je dessine sur e, en fait je dessine sur Form1.

Noter bien que e est visible uniquement dans Form1_Paint

Pour forcer le déclenchement de l'évènement Paint et dessiner, on utilise la méthode OnPaint.

X-G-2. Comment dessiner ?

La classe Graphics fournit des méthodes permettant de dessiner :


DrawImage     'Ajoute une image (BitMap ou MetaFile) à un graphics déjà crée.

DrawLine      'Trace une ligne

DrawString    'Ecrit un texte

DrawPolygon   'Dessine un polygone

...

En GDI+ on envoie des paramètres à la méthode pour dessiner:

Exemple:


MonGraphique.DrawEllipse( New Pen(Couleur),r)    'cela dessine une ellipse

Les 2 paramètres sont: la couleur et le rectangle dans lequel on dessine l'ellipse.

Pour travailler on utilise les objets:

Brush (Brosse)	Utilisé pour remplir des surfaces fermées avec des motifs, des couleurs ou des bitmaps. Il y a plusieurs types de brush: La brosse peut être pleine et ne contenir qu'une couleur: Dim SB= New SolidBrush(Color.Red) TextureBrush utilise une image pour remplir: Dim SB= New TextureBrush(MonImage) LinéarGradientBrush permet des dégradés (passage progressive d'une couleur à une autre). Dim SB= New LinearGradientBrush(PointDébut, PointFin,Color1, Color2) Les HatchBrush sont des brosse hachurées Dim HatchBrush hb = new HatchBrush(HatchStyle.ForwardDiagonal, Color.Green,Color.FromArgb(100, Color.Yellow)) Les PathGradient sont des brosses plus complexes.
Pen (Stylet)	Utilisé pour dessiner des lignes et des polygones, tels que des rectangles, des arcs et des secteurs. Comment créer un Stylet? Dim blackPen As New Pen(Color.Black) on donne la couleur Dim blackPen As New Pen(Color.Black, 3)on donne couleur et l'épaisseur Dim blackPen As New Pen(MyBrush) on peut même créer un stylet avec une brosse Propriétés de ce Stylet: DashStyle permet de faire des pointillés. StartCap et EndCap définissent la forme du début et de la fin du dessin (rond, carré, flèche..)
Font (Police)	Utilisé pour décrire la police utilisée pour afficher le texte. Dim Ft= New Font("Lucida sans unicode",60) 'paramètres=nom de la font et taille Il y a de nombreuses surcharges. Dim Ft= New Font("Lucida sans unicode",60, FontStyle.Bold)'pour écrire en gras
Color (Couleur)	Utilisé pour décrire la couleur utilisée pour afficher un objet particulier. Dans GDI+, la couleur peut être à contrôle alpha. System.Drawing.Color.Red pour le rouge
Point	Ils ont des cordonnées x, y Dim point1 As New Point(120, 120) ' Point avec des Integer ou des PointF 'avec des Singles
Rectangle	Permet de définir un rectangle. Dim r As New RectangleF(0, 0, 100, 100) On remarque que le F après Point ou Rectangle veut dire 'Float', et nécessite l'usage de Single.

Comment faire?

Dessiner une ligne sur le graphique:

Pour dessiner une ligne, on utilise DrawLine.


Dim blackPen As New Pen(Color.Black, 3)    'créer un stylet noir d'épaisseur 3
' Créer des points
Dim point1 As New Point(120, 120)    'créer des points
Dim point2 As New Point(600, 100)
' Dessine la ligne
e.Graphics.DrawLine(blackPen, point1, point2)

On aurait pu utiliser une surcharge de Drawline en spécifiant directement les coordonnées des points.


Dim x1 As Integer = 120
Dim y1 As Integer = 120
Dim x2 As Integer = 600
Dim y2 As Integer = 100
e.Graphics.DrawLine(blackPen, x1, y1, x2, y2)

Dessiner une ellipse:

Définir un rectangle dans lequel sera dessiné l'ellipse.


Dim r As New RectangleF(0, 0, 100, 100)

g.DrawEllipse(New Pen(Color.Red), r)' Dessinons l' ellipse

Dessiner une rectangle:


myGraphics.DrawRectangle(myPen, 100, 50, 80, 40)

Comme d'habitude on peut fournir après le stylet des coordonnées(4), des points (2) ou un rectangle.

Dessiner un polygone:


Dim MyPen As New Pen(Color.Black, 3)
' Créons les points qui définissent le polygone
Dim point1 As New Point(150, 150)
Dim point2 As New Point(100, 25)
Dim point3 As New Point(200, 5)
Dim point4 As New Point(250, 50)
Dim point5 As New Point(300, 100)
Dim point6 As New Point(350, 200)
Dim point7 As New Point(250, 250)
Dim curvePoints As Point() = {point1, point2, point3, point4, _
point5, point6, point7}
' Dessinons le Polygone.
e.Graphics.DrawPolygon(MyPen, curvePoints

Dessiner un rectangle plein:


e.FillRectangle(new SolidBrush(Color.red), 300,15,50,50)

Il existe aussi DrawArc, DrawCurve, DrawBezier DrawPie..

Ecrire du texte sur le graphique:

Pour cela on utilise la méthode DrawString de l'objet graphique:


g.DrawString ("Salut", Me.Font, New SolidBrush (ColorBlack), 10, 10)

Paramètres:

-Texte à afficher.

-Police de caractères

-Brosse , cela permet d'écrire avec des textures.

-Coordonnées.

Si on spécifie un rectangle à la place des 2 derniers paramètres,
le texte sera affiché dans le rectangle avec passage à la ligne si nécessaire:


Dim rectangle As New RectangleF (100, 100, 150, 150 )

Dim T as String= "Chaîne de caractères très longue"

g.DrawString (T, Me.Font, New SolidBrush (ColorBlack), Rectangle)

On peut même imposer un format au texte:

Exemple: centrer le texte.


Dim Format As New StringFormat()

Format.Aligment=StringAlignment.Center

g.DrawString (T, Me.Font, New SolidBrush (ColorBlack), Rectangle, Format)

On peut mesurer la longueur (ou le nombre de lignes) d'une chaîne:

Avec MeasureString

Exemple 1: centrer le texte: pour cela, calculer la longueur de la chaîne, puis calculer le milieu de l'écran moins la 1/2 longueur de la chaîne:


Dim W As Double= Me.DisplayRectangle.Width/2

Dim L As SizeF= e.Graphics.MeasurString (Texte, TextFont)

Dim StartPos As Double = W - (L.Width/2)

g.Graphics.MeasureString (T, Me.Font, New SolidBrush (ColorBlack), Rectangle, StartPos, 10)

Exemple 2:Calculer le nombre de ligne et le nombre de caractères d'une chaîne:


g.Graphics.MeasureString (T, Me.Font, New SolidBrush (ColorBlack), Rectangle,New StringFormat() 
_NombredeCaractères, NombredeLignes)

Ajouter une image sur le graphique:

Pour cela on utilise la méthode DrawImage de l'objet graphique:


g.Graphics.DrawImage(New Bitmap("sample.jpg"), 29, 20, 283, 212)

On peut travailler avec des images .jpeg .png .bmp .Gif .icon .tiff .exif

X-G-3. Travailler sur un Objet Image

Charger une image:

Si on veut utiliser une image bitmap ou vectoriel, il faut la mettre dans un Graphics. C'est la méthode DrawImage qui reçoit l'objet Metafile ou Bitmap comme argument. L'objet BitMap, si on le désire peut charger un fichier qui sera affiché.


Dim myBMP As New BitMap ("MonImage.bmp")

myGraphics.DrawImage(myBMP, 10, 10)

Le point de destination du coin supérieur gauche de l'image, (10, 10), est spécifié par les deuxième et troisième paramètres.

myGraphics.FromImage(myBMP) est aussi possible

On peut utiliser plusieurs formats de fichier graphique : BMP, GIF, JPEG, EXIF, PNG, TIFF et ICON.

Cloner une image:

La classe Bitmap fournit une méthode Clone qui permet de créer une copie d'un objet existant. La méthode Clone admet comme paramètre un rectangle source qui vous permet de spécifier la portion de la Bitmap d'origine à copier. L'exemple suivant crée un objet Bitmap en clonant la moitié supérieure d'un objet Bitmap existant. Il dessine ensuite les deux images.


Dim originalBitmap As New Bitmap("Spiral.png")'on charge un fichier png dans un BitMap
Dim sourceRectangle As New Rectangle(0, 0, originalBitmap.Width, _
originalBitmap.Height / 2) 'on définit un rectangle

Dim secondBitmap As Bitmap = originalBitmap.Clone(sourceRectangle, _
PixelFormat.DontCare)
'on définit un second BitMap Clonant une partie du 1ere BitMap avec le rectangle

'On met les 2 BitMap dans un  Graphics

myGraphics.DrawImage(originalBitmap, 10, 10)
myGraphics.DrawImage(secondBitmap, 150, 10)

Enregistrer une image sur disque:

On utilise pour cela la méthode Save.

Exemple: enregistrer le BitMap newBitMap dans 'Image1.jpg'


newBitmap.Save("Image1.jpg", ImageFormat.Jpeg)

X-G-4. Comment voir un Graphics ?

Si on a instancé un objet Graphics, on ne le voit pas (sauf s'il est lié à un contrôle). Pour le voir il faut le mettre dans un PictureBox par exemple:

Exemple:


Dim newBitmap As Bitmap = New Bitmap(200, 200) 'créons un BitMap

Dim g As Graphics = Graphics.FromImage(newBitmap)'créons un Graphics et y mettre le BitMap

Dim r As New RectangleF(0, 0, 100, 100)' Dessinons une ellipse

g.DrawEllipse(New Pen(Color.Red), r)

Comment voir l'ellipse?

Ajoutons un PictureBox au projet, et donnons à la propriété Image de ce PictureBox le nom du BitMap du Graphics:


PictureBox1.Image = newBitmap

L'ellipse rouge apparaît!! Si ,Si!!

Si on utilise un objet Graphics représentant la surface de dessin d'un contrôle:

Le fait de dessiner sur le graphics affiche automatiquement le dessin sur le contrôle.

Pour que le dessin soit 'persistant' voir l'exemple du logiciel de dessin ci dessous.

Paint déclenché par Resize

On peut récupèrer la référence de l'objet Graphics argument de l'évènement Paint d'un contrôle lorsque le contrôle est redessiné, un objet Graphics est fourni comme une valeur de PaintEventArgs.

Mais par défaut Paint n'est pas déclenché quand un contrôle ou formulaire est redimensionné.
Pour forcer à redessiner en cas de redimensionnement, il faut mettre le style Style.Resizedraw du formulaire ou du contrôle à true.


SetStyle (Style.Resizedraw, true)

Cette syntaxe marche, la suivante aussi (pour le formulaire)


Me.SetStyle (Style.Resizedraw, true) 'pour tous les objets du formulaire?

Mais PictureBox1.SetStyle (Style.Resizedraw, true) n'est pas accepté!!

X-G-5. Un exemple : Afficher un texte en 3D

Afficher un texte en 3d.


PrivateSub TextEn3D(ByVal g As Graphics, ByVal position As PointF, ByVal text AsString, ByVal ft As Font, 
_ByVal c1 As Color, ByVal c2 As Color)

    Dim rect AsNew RectangleF(position, g.MeasureString(text, ft))

    Dim bOmbre AsNew LinearGradientBrush(rect, Color.Black, Color.Gray, 90.0F)

 

    g.DrawString(text, ft, bOmbre, position)

 

    position.X -= 2.0F

    position.Y -= 6.0F

 

    rect = New RectangleF(position, g.MeasureString(text, ft))

    Dim bDegrade AsNew LinearGradientBrush(rect, c1, c2, 90.0F)

 

    g.DrawString(text, ft, bDegrade, position)

EndSub

X-G-6. Espace de noms

Pour utiliser les graphiques il faut que System.Drawing soit importé (ce qui est fait par défaut).

(Systém.Drawing.DLL comme références de l'assembly)

X-G-7. Programme simple de dessin

Un source très simple très didactique, pour dessiner avec la souris:

On appuie sur le bouton de la souris, on déplace la souris: cela dessine un trait.

Si on clique sur les boutons Rouge, Vert, Bleu cela change la couleur du trait.

Comment faire?

Dans Form1 on crée :

Une PictureBox définissant la zone de dessin: PictureBox1

Les boutons ButtonRouge, ButtonVert, ButtonBleu ayant dans leur propriété text respectivement 'Rouge', 'Vert', 'Bleu'.

Au niveau de la Classe on crée les variables ThePen de type Pen contenant la couleur en cours et PreviousPoint de type Point qui désigne le dernier point ou était la souris.

Les évènements Click des boutons ButtonRouge, ButtonVert, ButtonBleu modifie la couleur en cours:


ThePen.Color = Color.Blue

Le dessin est effectué par les procédures évènement de la souris:

MouseDown enregistre le précédent Point (les coordonnées de la souris sont fournis par le paramètre e, ce sont e.X et e.Y)

MouseMove: On teste si la souris est 'capturée' sur le PictureBox (c'est à dire si on est en glissé: déplacement de la souris bouton appuyé, cela donne à PictureBox1.Capture la valeur True).

Si la souris est capturée:


If PictureBox1.Capture Then

On récupère le Graphics de PictureBox1:


Dim NewGraphic As Graphics = PictureBox1.CreateGraphics()

On trace sur le graphics une ligne du PreviousPoint au Point actuel avec ThePen:


 NewGraphic.DrawLine(ThePen, PreviousPoint, NewPoint)

On détruit le graphics, puis on met dans PreviousPoint le point actuel.

Cela donne:


Imports System.Drawing

 

Public Class Form1

Inherits System.Windows.Forms.Form

 

Private PreviousPoint As Point ' Dernier point de la souris

Private ThePen As New System.Drawing.Pen(Color.Red) 'Un Pen pour dessiner.

 

Private Sub PictureBox1_MouseDown(ByVal sender As Object, ByVal e As System.Windows.Forms.MouseEventArgs) 
_Handles PictureBox1.MouseDown

Dim NewPoint As New Point(e.X, e.Y)

PreviousPoint = NewPoint

End Sub

 

 

Private Sub PictureBox1_MouseMove(ByVal sender As Object, ByVal e As System.Windows.Forms.MouseEventArgs) 
_Handles PictureBox1.MouseMove

If PictureBox1.Capture Then

Dim NewPoint As New Point(e.X, e.Y)

Dim NewGraphic As Graphics = PictureBox1.CreateGraphics()

NewGraphic.DrawLine(ThePen, PreviousPoint, NewPoint)

NewGraphic.Dispose()

PreviousPoint = NewPoint

End If

End Sub

 

 

Private Sub ButtonRouge_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) 
_Handles ButtonRouge.Click

ThePen.Color = Color.Red

End Sub

 

Private Sub ButtonVert_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) 
Handles ButtonVert.Click

ThePen.Color = Color.Green

End Sub

 

Private Sub ButtonBleu_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) 
_Handles ButtonBleu.Click

ThePen.Color = Color.Blue

End Sub

End Class

Dans une version VB6 de ce programme, je n'utilisais pas Capture, aussi j'utilisais une variable Globale 'Tracer': MouseDown lui donnait la valeur True, MouseUp la valeur False et dans MouseMove on traçait si 'Tracer' était à True.

Mais c'est plus facile avec Capture.

Problème:

Si une fenêtre est positionnée sur notre fenêtre de dessin puis enlevée, le dessin disparaît!!

En VB6, la propriété AutoRedraw de l'image permettait de rappeler automatiquement le BitMap du dessin et de faire réapparaître l'image, cela n'existe plus en VB.Net!!

A- On peut écrire une nouvelle méthode OnPaint de l'image (on la substitue grâce à Overrides), elle est déclenchée à chaque fois que le contrôle est redessiné; on y met du code qui redessine (forme géométrique..).


Protected Overrides Sub OnPaint(ByVal e As PaintEventArgs)

Dim myPen As New System.Drawing.Pen(System.Drawing.Color.Red)

Dim formGraphics As System.Drawing.Graphics

formGraphics = Me.CreateGraphics()

formGraphics.DrawLine(myPen, 0, 0, 200, 200)

myPen.Dispose()

formGraphics.Dispose()

End Sub

mais dans notre programme à moins d'enregistrer dans un tableau les coordonnées et couleur de chaque point puis de les redessiner un à un, ce n'est pas possible.

B- Comment faire l'équivalent de l'autoRedraw?


Class Form1

Private PreviousPoint As Point ' Dernier point de souris

Private ThePen As New System.Drawing.Pen(Color.Red)

Private MyBitMap As Bitmap = New Bitmap(200, 200) 'Je crée un BitMap

Private NewPoint As New Point 'point actuel


 

Private Sub PictureBox1_MouseDown(ByVal sender As Object, 
	_ByVal e As System.Windows.Forms.MouseEventArgs) Handles PictureBox1.MouseDown

NewPoint = New Point(e.X, e.Y)

PreviousPoint = NewPoint

End Sub

 

Private Sub PictureBox1_MouseMove(ByVal sender As Object, ByVal e As System.Windows.Forms.MouseEventArgs) 
_Handles PictureBox1.MouseMove

If PictureBox1.Capture Then

Dim NewPoint As New Point(e.X, e.Y)

Dim newgraphic As Graphics = Graphics.FromImage(MyBitMap) 'je crée un Graphics à partir du BitMap


newgraphic.DrawLine(ThePen, PreviousPoint, NewPoint)      'je dessine sur le Graphics  

PictureBox1.Image = MyBitMap                              'je passe le BitMap dans le PictureBox1  

 

PreviousPoint = NewPoint

End If

End Sub

 

End Class

Quand on crée un Graphics depuis un contrôle comme dans la première version, le graphics ne pointe pas sur la propriété image mais sur son affichage à l'instant T. Ce n'est pas mémorisé.

Beaucoup de contrôles .net ont une propriété image. A chaque rafraîchissement du contrôle si un bitmap est "attaché" à la propriété, le fond du contrôle est affiché automatiquement. Le picturebox est le plus simple de ces contrôles ... il ne fait que ça.

Donc en fait pour dessiner sur un contrôle (quel qu'il soit) tu n'as que 2 possibilités :

Redessiner tout à chaque fois dans l'évènement Onpaint
Lui affecter une image de fond et travailler sur celle ci

X-G-8. Faire un graphique

Comme cela:

Voir le cours sur Chart de Microsoft par moi même ici:http://plasserre.developpez.com/cours/chart/

X-H. Imprimer

Comment Imprimer ?

Prévoir une longue soirée, au calme, un bon siège, 1 g de paracétamol et un gros thermos de café!!

On verra que l'on peut utiliser pour imprimer:

A- La méthode .Net

Soit avec un composant 'PrintDocument'.

Soit avec une instance de 'la Class PrintDocument'.

B- On peut, en ajoutant une référence, imprimer comme en VB6 et c'est plus simple!!

X-H-1. Avec PrintDocument

X-H-1-a. Imprimer 'Hello' avec le composant 'PrintDocument'

L'utilisateur clique sur un bouton, cela imprime 'Hello'

Cet exemple utilise un 'composant PrintDocument'

Comment faire en théorie?

C'est le composant PrintDocument qui imprime.

En prendre un dans la boite à outils, le mettre dans un formulaire. Il apparaît sous le formulaire et se nomme PrintDocument1.

Pour imprimer il faut utiliser la méthode Print de ce composant PrintDocument; Il faut donc écrire l'instruction suivante:


PrintDocument1.Print

Cette instruction appelle la procédure évènement PrintDocument1_PrintPage du composant PrintDocument et qui contient la logique d'impression. Un paramètre de cet évènement PrintPage est l'objet graphique envoyé à l'imprimante (nommé e). C'est à vous de dessiner dans l'objet graphique (e) ce que vous voulez imprimer . En fin de routine, l'objet graphique sera imprimé (automatiquement).

En pratique:

Je prends un PrintDocument dans la boite à outils, je le met dans un formulaire. Il apparaît sous le formulaire et se nomme PrintDocument1.
Si je double-clique sur PrintDocument1 je vois apparaître la procédure PrintDocument1_PrintPage (qui a été générée automatiquement):
Private Sub PrintDocument1_PrintPage(ByVal sender As System.Object, _ByVal e As System.Drawing.Printing.PrintPageEventArgs) Handles PrintDocument1.PrintPage End Sub
C'est cette procédure qui est fondamentale et qui contient les routines d'impression écrites par le programmeur. Les routines d'impression agissent sur l'objet graphique qui sera utilisé pour imprimer , cet objet graphique est fourni dans les paramètres de la procédure(ici c'est e qui est de type PrintPageEventArgs) e.graphics est donc l'objet graphique sur lequel il faut écrire ou dessiner ce qui doit être imprimé.
Dans cette routine PrintPage,on ajoute donc le code dessinant un texte (DrawString) sur l'objet graphique 'e':
e.Graphics.DrawString("Hello", New Font("Arial", 80, FontStyle.Bold), Brushes.Black, 150, 125)
Enfin je dessine un bouton nommé 'ButtonPrint' avec une propriété Text contenant "Imprimer Hello" et dans la procédure ButtonPrint_Click j'appelle la méthode Print
PrintDocument1.Print()

Voici le code complet:


Private Sub PrintDocument1_PrintPage(ByVal sender As System.Object, 
	_ByVal e As System.Drawing.Printing.PrintPageEventArgs) Handles PrintDocument1.PrintPage

e.Graphics.DrawString("Hello", New Font("Arial", 80, FontStyle.Bold), Brushes.Black, 150, 125)

End Sub

Private Sub ButtonPrint_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ButtonPrint.Click

PrintDocument1.Print()

End Sub

Si je clique sur le bouton 'ImprimerHello' cela imprime un gros 'Hello'.

La méthode Print d'un PrintDocument déclenche l'évènement PrintPage de ce PrintDocument qui contient le code dessinant sur le graphique de la page à imprimer. En fin de routine PrintPage le graphique est imprimer sur la feuille de l'imprimante.

Toutes les méthodes graphiques écrivant, dessinant, traçant des lignes... sur un graphique permettent donc d'imprimer.

X-H-1-a-i. Imprimer un dessin

Créons une ellipse bleue à l'intérieur d'un rectangle avec la position et les dimensions suivantes : début à 100, 150 avec une largeur de 250 et une hauteur de 250.


Private Sub PrintDocument1_PrintPage(ByVal sender As Object, 
	_ByVal e As System.Drawing.Printing.PrintPageEventArgs) Handles PrintDocument1.PrintPage
   e.Graphics.FillEllipse(Brushes.Blue, New Rectangle(100, 150, 250, 250))
End Sub

X-H-1-a-ii. Afficher un Message Box indiquant 'Fin d'impression'

On a étudié l'évènement PrintPage, mais il existe aussi les évènements:

BeginPrint et EndPrint respectivement déclenchés en début et fin d'impression

Il suffit d'utiliser l'évènement EndPrint pour prévenir que l'impression est terminée:


Private Sub PrintDocument1_EndPrint(ByVal sender As Object, ByVal e As System.Drawing.Printing.PrintEventArgs) 
_Handles PrintDocument1.EndPrint
   MessageBox.Show("Fin d'impression")
End Sub

On peut même fignoler et afficher "Fin d'impression de Nom du document"

Il faut avoir renseigné le DocumentName:

PrintDocument1.DocumentName = "MyTextFile"

Puis écrire:


Private Sub PrintDocument1_EndPrint(ByVal sender As Object, ByVal e As System.Drawing.Printing.PrintEventArgs) 
_Handles PrintDocument1.EndPrint
   MessageBox.Show( "Fin d'impression de "+PrintDocument1.DocumentName)
End Sub

X-H-1-b. Même programme : Imprimer 'Hello' mais avec la Classe PrintDocument

L'utilisateur clique sur un bouton, cela imprime 'Hello'

Cet exemple utilise 'une instance de la Classe PrintDocument'. On ne met pas de composant 'PrintDocument' dans le formulaire.

Comment faire en théorie?

Il faut importer l'espace de nom 'Printing' par :


Imports System.Drawing.Printing

Il faut créer une instance de la Classe PrintDocument dans le module.


 Dim pd As new PrintDocument()

Il faut créer soi même, une routine pd_PrintPage .


Private Sub pd_PrintPage(sender As object, ev As System.Drawing.Printing.PrintPageEventArgs)
End sub

Il faut indiquer le "lien" entre l'objet pd et la routine évènement PrintPage


AddHandler pd.PrintPage, AddressOf Me.pd_PrintPage

Dans la procédure Button_Click d'un bouton "Imprimer" il faut appeler la méthode Print du PrintDocument pour effectuer l'impression du document .

pd.Print

Cela déclenche la procédure Private Sub pd_PrintPage précédemment écrite, dans laquelle on a ajouté:


ev.Graphics.DrawString ("Hello", printFont, Brushes.Black, leftMargin, yPos, new StringFormat()).

Cela donne le code complet:


Imports System.Drawing.Printing

 

Public Class Form1

Inherits System.Windows.Forms.Form

 

Dim pd As  New PrintDocument 'Assumes the default printer


Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

    AddHandler pd.PrintPage, AddressOf Me.Pd_PrintPage

End Sub


Private Sub Pd_PrintPage(ByVal sender As System.Object, ByVal e As System.Drawing.Printing.PrintPageEventArgs)

e.Graphics.DrawString("Hello", New Font("Arial", 80, FontStyle.Bold),   Brushes.Black, 150, 125)

End Sub


Private Sub ButtonPrint_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) 
_Handles ButtonPrint.Click

    pd.Print()

End Sub

 

End Class

X-H-1-b-i. Comment choisir l'imprimante ?

Le composant PrintDialog permet le choix de l'imprimante, de la zone à imprimer (tout, la sélection..) et donne accès aux caractéristiques de l'imprimante.

Comment l'utiliser?

Il faut créer une instance de PrintDialog:


    Dim dlg As New PrintDialog

Il faut indiquer au PrintDialog sur quel PrintDocument travailler:


    dlg.Document = pd

Puis ouvrir la fenêtre PrintDialog avec la méthode ShowDialog.

L'utilisateur choisit son imprimante puis clique sur 'Ok'.

Exemple:

Quand l'utilisateur clique sur le bouton ButtonPrint ('Imprimer') la fenêtre PrintDialog s'ouvre:

Voici le code complet:


Private Sub ButtonPrint_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) _ 
Handles ButtonPrint.Click

Dim dlg As New PrintDialog

dlg.Document = pd

Dim result As DialogResult = dlg.ShowDialog()

If (result = System.Windows.Forms.DialogResult.OK) Then

    pd.Print()

End If

 

End Sub

X-H-1-b-ii. Comment modifier la page à imprimer ?

Comment choisir d'imprimer en portrait ou paysage? modifier les marges..

Il faut utiliser un composant PageSetUpDialog.

Pour stocker les informations sur la page (marges...) il faut un PageSetting

Je lie le PageSetting au PageSetUpDialog en donnant à la propriété PageSettings du PageSetUpDialog le nom du PageSetting.

puis j'ouvre le PageSetUpDialog.

Au retour le PageSetting contient les modifications, je les 'passe' au PrintDocument avant d'imprimer.

Cela donne:


Dim psDlg As New PageSetupDialog

Dim LePageSettings As New PageSettings

psDlg. PageSettings = LePageSettings

psDlg.ShowDialog()

pd.DefaultPageSettings = LePageSettings

X-H-1-c. Prévisualisation de la page à imprimer ?

On utilise pour cela un PrintPreviewDialog, on lui indique quel PrintDocument pré visualiser en l'assignant à sa méthode document puis on l'affiche par ShowDialog().


Dim dllg As New PrintPreviewDialog

dllg.Document = pd

dllg.ShowDialog()

X-H-1-d. Construction d'une application d'impression complexe

Comment imprimer le contenu d'un fichier texte?

Tous les didacticiels (Microsoft compris) donnent cet exemple.

La première chose que vous devez faire est d'écrire votre logique d'impression. Pour cela, quand la méthode PrintDocument.Print() est appelée, les événements suivants sont déclenchés.

BeginPrint
PagePrint (un ou plusieurs s'il y a plusieurs pages à imprimer)
EndPrint

L'argument d'événement de PagePrint (PagePrintEventArgs) comprend une propriété HasMorePages. Si celle-ci a la valeur True lors du retour de votre gestionnaire d'événements, PrintDocument définit une nouvelle page et déclenche de nouveau l'événement PagePrint.

Voyons la logique dans votre gestionnaire d'événements PagePrint :

Imprimez le contenu de la page en utilisant les informations des arguments d'événement. Les arguments d'événement contiennent l'objet Graphics pour l'imprimante, le PageSettings pour cette page, les limites de la page, et la taille des marges.
Il faut dans la procédure PagePrint imprimer ligne par ligne en se déplaçant à chaque fois vers le bas d'une hauteur de ligne.

Pour 'simplifier', on considère que chaque ligne ne déborde pas à droite!!
Déterminer s'il reste des pages à imprimer.
Si c'est le cas, HasMorePages doit être égal à True.
S'il n'y a pas d'autres pages, HasMorePages doit être égal à False.


Public Class ExampleImpression
    Inherits System.Windows.Forms.Form

    ....

    private printFont As Font
    private streamToPrint As StreamReader

    Public Sub New ()
        MyBase.New
        InitializeComponent()
    End Sub

    'Evénement survenant lorsque l'utilisateur clique sur le bouton 'Imprimer'
    Private Sub printButton_Click(sender As object, e As System.EventArgs)

        Try
            streamToPrint = new StreamReader ("PrintMe.Txt")
            Try
                printFont = new Font("Arial", 10)
                Dim pd as PrintDocument = new PrintDocument() 'déclaration du PrintDocument
                AddHandler pd.PrintPage, AddressOf Me.pd_PrintPage
                pd.Print()
            Finally
                streamToPrint.Close()
            End Try

        Catch ex As Exception
            MessageBox.Show("Une erreur est survenue: - " + ex.Message)
        End Try

    End Sub

    'Evènement survenant pour chaque page imprimer
    Private Sub pd_PrintPage(sender As object, ev As System.Drawing.Printing.PrintPageEventArgs)

        Dim lpp As Single = 0    'nombre de ligne par page
        Dim yPos As Single =  0  'ordonnée   
        Dim count As Integer = 0 'numéro de ligne
        Dim leftMargin As Single = ev.MarginBounds.Left
        Dim topMargin As Single = ev.MarginBounds.Top
        Dim line as String

        'calcul le nombre de ligne par page
        ' hauteur de la page/hauteur de la police de caractère
        lpp = ev.MarginBounds.Height  / printFont.GetHeight(ev.Graphics)

       
        'lit une ligne dans le fichier
        line=streamToPrint.ReadLine()
        

        'Boucle affichant chaque ligne    

        while (count < lpp AND line <> Nothing)

            yPos = topMargin + (count * printFont.GetHeight(ev.Graphics))

            'Ecrit le texte dans l'objet graphique
            ev.Graphics.DrawString (line, printFont, Brushes.Black, leftMargin, _
                                    yPos, new StringFormat())

            count = count + 1

            if (count < lpp) then
                line=streamToPrint.ReadLine()
            end if

        End While

        'S'il y a encore des lignes, on réimprime une page
        If (line <> Nothing) Then
            ev.HasMorePages = True
        Else
            ev.HasMorePages = False
        End If

    End Sub

    ....

End Class

On a vu que pour 'simplifier', on considère que chaque ligne ne déborde pas à droite.

Dans la pratique, pour gérer les retours à la ligne automatiques on peut dessiner dans un rectangle en utilisant une surcharge de DrawString.


Dim rectangle As New RectangleF (100, 100, 150, 150 )

Dim T as String= "Chaîne de caractères très longue"

g.DrawString (T, Me.Font, New SolidBrush (ColorBlack), Rectangle)

On peut mesurer la longueur (ou le nombre de lignes) d'une chaîne:

Avec MeasureString

(Voir la page sur les graphiques.)

X-H-1-e. Propriétés du 'PrintDocument'

On peut sans passer par une 'boite de dialog' gérer directement l'imprimante, les marges, le nombre de copies..

Si pd est le PrintDocument:

pd.PrinterSetting désigne l'imprimante en cours

pd.PrinterSetting.PrinterName retourne ou définit le nom de cet imprimante

pd.PrinterSetting.Printerresolution donne la résolution de cette imprimante.

pd.PrinterSetting.installedPrinted donne toutes les imprimantes installées.

La propriété DefaultPageSetting est en rapport avec les caractéristiques de la page.

pd.PrinterSetting.DefaultPageSetting.Margins donne les marges

pd.PrinterSetting.PrinttoFile permettrait d'imprimer dans un fichier (non testé)

X-H-1-f. Imprime le formulaire en cours

Exemple fournit par Microsoft.

La routine CaptureScreen capture l'image du formulaire en cours et la met dans memoryImage. puis memoryImage est passé dans l'objet graphique e qui est imprimé.


Private Declare Function BitBlt Lib "gdi32.dll" Alias "BitBlt" (ByVal _
   hdcDest As IntPtr, ByVal nXDest As Integer, ByVal nYDest As _
   Integer, ByVal nWidth As Integer, ByVal nHeight As Integer, ByVal _
   hdcSrc As IntPtr, ByVal nXSrc As Integer, ByVal nYSrc As Integer, _
   ByVal dwRop As System.Int32) As Long
Dim memoryImage As Bitmap
Private Sub CaptureScreen()
   Dim mygraphics As Graphics = Me.CreateGraphics()
   Dim s As Size = Me.Size
   memoryImage = New Bitmap(s.Width, s.Height, mygraphics)
   Dim memoryGraphics As Graphics = Graphics.FromImage(memoryImage)
   Dim dc1 As IntPtr = mygraphics.GetHdc
   Dim dc2 As IntPtr = memoryGraphics.GetHdc
   BitBlt(dc2, 0, 0, Me.ClientRectangle.Width, _
      Me.ClientRectangle.Height, dc1, 0, 0, 13369376)
   mygraphics.ReleaseHdc(dc1)
   memoryGraphics.ReleaseHdc(dc2)
End Sub
Private Sub PrintDocument1_PrintPage(ByVal sender As System.Object, _
   ByVal e As System.Drawing.Printing.PrintPageEventArgs) Handles _
   PrintDocument1.PrintPage
   e.Graphics.DrawImage(memoryImage, 0, 0)
End Sub
Private Sub PrintButton_Click(ByVal sender As System.Object, ByVal e As _
   System.EventArgs) Handles PrintButton.Click
   CaptureScreen()
   PrintDocument1.Print()
End Sub

X-H-1-g. Imprime un contrôle DataGrid

Exemple fourni par Microsoft.

Cet exemple nécessite :

un contrôle Button, nommé ImprimerGrid, dans le formulaire ;
un contrôle DataGrid nommé DataGrid1 ;
un composant PrintDocument nommé PrintDocument1.

Comme d'habitude PrintPage imprime e.Graphics.

D'après ce que j'ai compris, l'évènement Paint redessine un contrôle.

mais on peut choisir le contrôle et l'endroit ou le redessiner.

Je redessine donc grâce à Paint,le DataGrid dans e.graphics.

PaintEventArgs Fournit les données pour l'événement Paint:

PaintEventArgs spécifie l'objet graphics à utiliser pour peindre le contrôle, ainsi que le ClipRectangle dans lequel le peindre.

InvokePaint déclenche l'évènement Paint


Private Sub ImprimerGrid_Click(ByVal sender As System.Object, ByVal e As _
   System.EventArgs) Handles PrintGrid.Click
   PrintDocument1.Print()
End Sub

Private Sub PrintDocument1_PrintPage(ByVal sender As System.Object, _
   ByVal e As System.Drawing.Printing.PrintPageEventArgs) Handles _
   PrintDocument1.PrintPage
   Dim myPaintArgs As New PaintEventArgs(e.Graphics, New Rectangle(New _
      Point(0, 0), Me.Size))
   Me.InvokePaint(DataGrid1, myPaintArgs)
End Sub

Imprime le texte d'un RichTextBox

Voir Imprimer le contenu d'une RichtextBox

Simple, non!! Je plaisante!!

X-H-2. Imprimer comme en VB6 avec un objet 'Printer'

Microsoft propose un PowerPack de compatibilité vb6 le 'Microsoft.VisualBasic.PowerPacks.Printing.Printer' qui ajoute à VB 2005 une Classe permettant d'imprimer 'comme en VB6'; cela permet d'utiliser votre code de routine d'impression VB6 ou de créer des routines d'impression beaucoup plus simple!!

Télécharger le PowerPack Printercompatibility 1 ici: http://msdn2.microsoft.com/en-us/vbasic/bb219077.aspx

Après avoir installé le Pack, aller dans le menu Project cliquer sur 'Ajouter une référence'.

Sur l'onglet NET , cliquez sur Microsoft.VisualBasic.PowerPacks.Printing.Printer, puis sur OK.

Dans le Code, ajouter en haut du module:

Imports Microsoft.VisualBasic.PowerPacks.Printing.Compatibility.VB6

Maintenant on peut utiliser du code VB6 pour imprimer:


Dim pr As New Printer        'Instanciation de l'imprimante par défaut

Dim pFont As New Font("Arial", 14)    'Une nouvelle font

pr.Font = pFont

pr.Print("This text will print in 14 point ")  'Texte à imprimer

pr.EndDoc()    'fin, on lance l'impression

Simple, non!! Je plaisante pas!!

DrawMode, DriverName, hDC, Port, TrackDefault, et Zoom n'existent plus.

Par contre il y a en plus: PrintAction property qui permet un print preview ou permet d'imprimer dans un fichier.

Il y a aussi la PrinterCollection class qui contient les imprimantes . La global Printers collection permet de sélectionner une imprimante.

Précédent Sommaire Suivant

Les sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre cette page de présentation de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © . Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.