I. Introduction▲
Tout comme Word, Excel, Access, Visio et PowerPoint, Outlook supporte le VBA ( Visual Basic for Applications). Il est doté de l'éditeur de code VBE (Visual Basic Editor), rien dans celui-ci ne change avec les autres applications de la suite office, la seul différence se situe au niveau du Code sur les Objets et Collections.
II. Présentation de l'éditeur de Code▲
L'éditeur de code est accessible depuis le menu 'Outils', sélectionnez 'Macro' puis Visual Basic Editor ou bien directement par l'association des touches ALT + F11.
Cette interface est identique dans toutes les applications de la suite Office supportant
le VBA.
Elle est également similaire à la version 2003. Les barres d'outils sont paramétrables en réalisant
un clic droit sur une des barres et en sélectionnant 'Personnaliser...' vous pouvez la
personnaliser. Deux boutons non présents dans les barres d'outils sont pour moi très intéressant,
nous allons les activer :
Clic droit sur une barre d'outils -> Onglet Commandes -> Sélectionnez Edition ->
Sélectionnez Commenter bloc et placer le dans une des barres d'outils -> réalisez la même
opération avec Ne pas commenter bloc.
Ces deux commandes permettent de mettre ou bien d'enlever l'ensemble de la sélection en tant que
commentaires, en phase de développement ceci est très pratique.
Ces mêmes commandes sont disponibles depuis la barre d'outils 'Edition', cette barre d'outil permet l'indentation de votre code.
L'indentation est aussi importante que les commentaires dans un code, ceci permet en un coup de d'œil de diviser le code par bloc, les boucles,
les tests, les propriétés, etc. Vous avez le choix soit vous définissez votre indentation vous même par le biais des commandes de retrait (Tab et
retrait négatif), soit en installant un utilitaire qui le fait pour vous. Pour l'utilitaire je vous invite à consulter la page d'outils d'Outlook
vers l'utilitaire Smart identer.
L'éditeur de code est doté de plusieurs fenêtres, nous allons aborder les plus utilisées :
Explorateur de projet :
Cette fenêtre permet de sélectionner les différents Modules, Modules de classe et Formulaires
présents dans ce projet.
Fenêtre de visualisation :
Celle-ci permet d'afficher le code des différents Modules et Modules de classe ou bien l'Objet
Formulaire ou son code.
Fenêtre d'exécution :
Cette fenêtre est très pratique lors du développement, vous pouvez y capturer un résultat lors
de l'exécution d'un code. Vous pouvez également exécuter un code directement dans cette fenêtre.
Sub
Test
(
)
'Déclaration de la variable
Dim
strTest As
String
'Chargement de la variable
strTest =
"Bonjour ceci est un test"
'Capture la valeur de la variable dans la fenêtre d'exécution
Debug.Print
strTest
End
Sub
Lors de l'exécution du code précédent, la fenêtre d'exécution affiche ceci comme résultat.
Il vous est possible d'exécuter directement du code dans cette fenêtre pour contrôler
le retour. L'exécution du code suivant dans la fenêtre d'exécution permet de visualiser
la valeur de retour de la boîte de message.
?msgbox("Voulez-vous continuer",vbYesNoCancel,"Ceci est un test")
Collez ce code dans la fenêtre d'exécution et exécutez-le en validant par la touche Enter.
La fenêtre suivante s'ouvre :
Une valeur de retour s'affiche dans la fenêtre en fonction du bouton que vous avez sélectionné, 6 pour Yes, 7 pour Non et 2 pour Annuler. Nous verrons plus tard à quoi cela peut servir.
Fenêtre de Propriétés :
Cette fenêtre permet de lister et de modifier les propriétés des Modules, Modules de classe
et surtout des Formulaires.
Plusieurs outils permettent de rendre des tâches utiles, pour cela je vous renvoie vers
la page d'outils pour Outlook :
Editeurs VBA pour Outlook
II-A. Options de l'éditeur▲
L'éditeur peut être paramétré à votre guise, pour cela depuis le menu Outils sélectionnez Options, une fenêtre comportant 4 onglets s'affiche.
Il ne vous reste plus qu'à sélectionner les options selon vos désirs. Si vous êtes
débutant avec le VBA je vous conseil de cocher l'option 'Déclaration des variables obligatoire',
cette option vous oblige à déclarer chaque variable à utiliser. Diverses options vous sont proposées :
- Vérification automatique de la syntaxe => permet de contrôler la saisie et vous
signale toutes erreurs de syntaxe.
- Déclaration des variables obligatoire => Rend obligatoire la déclaration des variables du projet.
- Complément automatique des instructions => Affiche au cours de la saisie une liste d'objets, des propriétés et des méthodes
en fonction des premières lettres saisies.
- Info Express automatique => Affiche dans une info bulle la liste des paramètres de la fonction ou
de la méthode.
- Info bulles automatiques => Permet lors de l'exécution Pas à Pas d'une macro
d'afficher dans une info bulle les valeurs des variables en pointant dessus.
- Retrait automatique => Permet lors d'un retour chariot d'avoir le même retrait que la ligne
précédente, option pratique pour bien indenter le code.
- Largeur de la tabulation => nombre de caractères lors d'une tabulation.
- Edition de texte par glisser-déposer => Déplace l'ensemble d'une sélection par la souris.
- Affichage du module complet par défaut => Toutes les procédures sont affichées lors de l'ouverture du Module.
- Séparation des procédures => Place un trait horizontal pour séparer les procédures.
Cet onglet permet de modifier la mise en forme d'affichage du code dans les Modules.
- Affichage de la grille => Affiche une grille lors de l'affichage d'objet de
Formulaire. Celle-ci est très pratique pour la mise en place d'éléments tels les boutons, les
zones de saisies, les listes déroulantes, etc.
- Largeur et hauteur => Définissent la hauteur et largeur du quadrillage (de 2 à 60 points).
- Aligner les contrôles sur la grille => Permet de rendre la grille magnétique pour le
placement des éléments.
- Afficher les info-bulles => Affiche les info-bulles des commandes de barres d'outils.
- Réduire le projet masque les fenêtres => Option concernant la fenêtre Explorateur
de projets, celle-ci permet de réduire les sous dossiers lors de la réduction du dossier principal.
- Avertir avant perte d'état => Affiche un message lorsque l'action réinitialise
le projet et provoque la perte de données.
- Arrêt sur toutes les erreurs => Lors d'une erreur le projet passe en mode arrêt, même
sans gestion d'erreur et celle-ci ne doit pas être présente dans un Module de classe.
- Arrêt dans les modules de classe => Lors d'une erreur dans un module de classe, celui-ci
passe en mode arrêt sur la ligne incriminée.
- Arrêt sur les erreurs non gérées => Avec une gestion d'erreurs, celles-ci sont interceptées par
le gestionnaire. S'il n'y a aucune gestion et hors module de classe, le projet passe en mode arrêt sur la ligne
incriminée, si l'erreur est située dans un module de classe le projet s'arrête sur la ligne d'appel
du Module de classe.
- Compilation sur demande => Si cochée, le projet n'est compilé que sur demande, ceci
permet un démarrage plus rapide. Si non cochée le projet est compilé avant l'exécution.
- Compilation en arrière-plan => N'est disponible que si l'option précédente est sélectionnée.
Permet de finir la compilation en arrière plan s'il n'y a aucune activité. Permet d'augmenter la vitesse
d'exécution.
- Permet de définir les fenêtres affichées et ancrées sur l'écran.
III. Les bases du VBA▲
Nous allons développer dans ce chapitre les bases du VBA. Ceci est valable pour toutes les applications Office intégrant le VBA.
III-A. Les Variables▲
Les variables permettent de stocker des données de différents types. Comme son
nom l'indique sont contenu est variable, la variable peut être lue ou modifiée
dans votre code. Si l'option Déclaration Obligatoire
(-> ) est cochée vous devez déclarer
cette variable par l'instruction Dim, abrégé de Dimension et indique à VBA les dimensions
de la zone de stockage à laquelle la variable fait référence, suivit du nom que vous voulez donner à la variable
et pour finir vous devez lui définir son type.
Si l'option n'est pas cochée vous n'êtes pas obligé de déclarer les variables,
l'application définira la variable en tant que Variant, mais dans un soucis
d'espace pour la mémoire il est préférable de définir le type de la variable car le type
Variant supporte toutes les données, par exemple vous avez besoin d'une Variable de type
Boolean (ayant pour valeur logique True (Vrai) ou False (Faux)) je ne vois pas l'intérêt
d'utiliser une variable de type Variant qui nécessite beaucoup plus de ressources. Ce qui est
démontré par le tableau suivant :
Type de Données | Valeurs autorisées | Détails |
---|---|---|
Boolean | True (-1) ou False (0) | Valeur logique True (Vrai) ou False (Faux) |
Byte | 0 à 255 | Nombre entier positif inclus dans la fourchette |
Integer | -32 768 à 32 767 | Nombre entier inclus dans la fourchette |
Long | -2 147 483 648 à 2 147 483 647 | Nombre entier inclus dans la fourchette |
Single | Valeurs négatives : -3,402823E38 à -1,401298E-45 Valeurs positives : 1,401298E-45 à 3,402823E38 |
Valeur à virgule flottante à simple précision |
Double | Valeurs négatives : -1,79769313486232E308 à -4,94065645841247E-324 Valeurs positives : 4,94065645841247E-324 à 1,79769313486232E308 |
Valeur à virgule flottante à double précision |
Currency | -922 337 203 685 477,5808 à 922 337 203 685 477,5807 | Nombre Réel de 19 chiffres comprenant 4 chiffres après la virgule |
Decimal | Sans décimale : +/- 79 228 162 514 264 337 593 543 950 335 Avec décimal : 7,9228162514264337593543950335 |
Nombre précis avec 29 chiffres avant le séparateur et jusqu'à 28 à droite du séparateur |
Date | de 01/01/100 au 31/12/9999 | Date et/ou heure |
Object | Référence aux Objets VBA | Objet VBA |
String | de 0 à 2 milliards | Chaîne de caractères de longueur variable |
String | de 0 à 65 400 | Chaîne de caractères de longueur fixe |
Variant | N'importe quelle valeur numérique jusqu'à la fourchette d'une valeur double. | Supporte toutes les données (fourchette identique à celle d'une chaîne de longueur variable) |
Code pour déclarer une variable :
Dim
strVariable As
String
Le code précédent permet de déclarer la variable strVariable en tant que String (chaîne de caractères).
Vous pouvez donner le nom que vous voulez à une Variable, vous ne pouvez mettre d'espace, de mots réservés par VBA et de caractères spécifiques, par contre vous pouvez mettre des underscores ( _ ), une obligation sur le premier caractère : il doit être de forme Alphanumérique et non numérique. Je vous invite à mettre un préfixe devant vos variables ceci permet d'un seul coup d'œil de voir le type de la variable. Pour plus d'informations sur la typographie je vous invite à lire le tutoriel d'argyronet sur le Descriptif des conventions typographique du code Visual Basic et de Télécharger le fichier Excel des principaux préfixes normalisés
III-A-1. Les Variables dans le programme▲
Pour affecter une donnée à une Variable, il vous suffit de dire au programme MaVariable égale ça :
strVariable =
"Bonjour"
Comme la donnée affectée à la Variable de type String est une chaîne de caractères nous entourons la données de guillemets (ou double Quotes). Dans cet exemple la Variable à pour donnée Bonjour. Il vous est possible d'imbriqué une Variable dans une Variable :
Sub
Variable
(
)
Dim
strVariable As
String
Dim
strDate As
String
Dim
strResultat As
String
strVariable =
"Bonjour, nous sommes le "
strDate =
"29/03/2008"
strResultat =
strVariable &
strDate
MsgBox
strResultat
End
Sub
Dans l'exemple précédent nous déclarons 3 Variables de type String, ensuite dans le code nous affectons comme données Bonjour, nous sommes le à la VariablestrVariable, nous affectons également la date 29/03/2008 à la Variable strDate. Nous stockons la concaténation des deux Variables dans la Variable strResultat que nous affichons dans une boîte de message. Voici le résultat de ce code :
Maintenant nous allons améliorer ce code en concaténant une Variable String
avec une Variable Date qui correspond à la date du jour, pour cela nous allons changer le type
de la Variable ainsi que son préfixe et lui affecter la date du jour :
Sub
Variable
(
)
Dim
strVariable As
String
Dim
dtmDate As
Date
Dim
strResultat As
String
strVariable =
"Bonjour, nous sommes le "
dtmDate =
Date
strResultat =
strVariable &
dtmDate
MsgBox
strResultat
End
Sub
Le résultat est identique :
III-B. Les Constantes▲
A l'instar des Variables, les Constantes ne sont pas modifiables par programme. Lors de sa déclaration nous lui affectons une donnée qui ne changera pas. Pour se faire nous remplaçons le Dim par l'abrégé Const pour Constante, vous devez lors de la déclaration lui affecter sa valeur :
Const
strConstante As
String
=
"Bonjour, nous sommes le "
VBA dispose de plusieurs Constantes prédéfinies sans que vous ayez besoin de les
déclarer. Ceci pour chaque application supportant le VBA, ces Constantes ont pour
préfixes l'abrégé de l'application correspondante :
- wd pour Word
- xl pour Excel
- ac pour Access
- pp pour Power Point
- ol pour Outlook
- vb pour les constantes communes à Office
Pour consulter l'ensemble des Constantes, je vous invite à consulter l'aide VBA (F1 depuis l'éditeur VBE) ou bien depuis l'explorateur d'objet de l'éditeur VBE (F2 depuis l'éditeur VBE).
Je vous invite à consulter les tutoriels de Miche TANGUY et de Maxence HUBICHE :
Les variables
Les fondamentaux des Variables et des Constantes en VBA
III-B-1. Les Constantes dans le code▲
L'appel de la Constante s'effectue exactement comme une Variable seul la déclaration diffère.
Sub
Variable
(
)
Const
strConstante As
String
=
"Bonjour, nous sommes le "
Dim
dtmDate As
Date
Dim
strResultat As
String
dtmDate =
Date
strResultat =
strConstante &
dtmDate
MsgBox
strResultat
End
Sub
Le résultat de ce code reste inchangé :
III-C. La portée des Variables et Constantes▲
La portée d'une Variable ou Constante permet de définir le périmètre où celle-ci sera utilisée.
2 facteurs entrent en jeu :
- L'endroit où la Variable et/ou la Constante sont déclarées.
- Le mot-clé utilisé lors de la déclaration.
Si la Variable ou la Constante est déclarée dans la Procédure, celle-ci
est dite Privée, la déclaration s'effectue par les mots-clés Dim ou Private.
Ces données ne seront exploitées que dans la Procédure où elles sont déclarées, en sortant de la
Procédure celles-ci sont réinitialisées et ne peuvent être exploitées. Pour garder
la valeur pour une éventuelle réutilisation dans la procédure il faut utiliser la clé
Static, ces données seront réinitialisées lors de la fermeture de l'application.
Si la Variable ou la Constante est déclarée en début du Module avant
la première Procédure, la déclaration s'effectue par les mots-clés Dim et
Private. Ces données ne sont exploitables que dans le module de déclaration, c'est à
dire dans toutes les Procédures de ce Module.
La dernière possibilité s'effectue par le mot-clé Public, ceci définit que la
Variable ou la Constante est utilisable dans tout le projet en cours. Elle
est réinitialisée lors de la fermeture de l'application.
Aucune donnée n'est sauvegardée dans l'application entre deux ouvertures. Si vous avez besoin de sauvegarder une donnée d'une ouverture à l'autre il vous est possible de créer une entrée dans la base de registre (avec modération) ou bien de créer un fichier texte que vous consultez à l'ouverture de l'application.
III-D. Les Fonctions intégrées▲
VBA possède un nombre conséquent de fonctions intégrées permettant de réaliser
des conversions, des calculs mathématiques, de traitement de texte ou de caractères,
des opérations sur les heures et dates, manipulation financière et des tests de valeurs.
Au vu du nombre nous n'allons pas développer l'ensemble des fonctions intégrées, je
vous invite à consulter l'aide VBA disponible depuis l'éditeur VBA (touche F1), dans la
zone de recherche taper 'fonctions' et lancer la recherche vous trouverez l'ensemble des
fonctions disponibles, commentées et avec des exemples.
III-D-1. Fonction Format▲
Cette fonction est très utilisée, elle permet de mettre en forme des données par des
formats prédéfinis ou bien par l'utilisateur, nous allons parler de celles définies par
l'utilisateur pour les prédéfinis je vous renvoie sur l'aide VBA :
Dates et Heures :
Date correspond à la date du jour (ici 01/04/2008) et Time -> 09h05m09s
Format | Détail | Code | Résultat |
---|---|---|---|
d | Renvoie le jour (en chiffre) du mois de la date passée en paramètre | Format (Date,"d") | 1 |
dd | Renvoie le jour (sur deux chiffres) du mois de la date passée en paramètre | Format (Date,"dd") | 01 |
ddd | Renvoie le jour (abrégé) du mois de la date passée en paramètre | Format (Date,"ddd") | mar. |
dddd | Renvoie le jour (en toutes lettres) du mois de la date passée en paramètre | Format (Date,"dddd") | mardi |
ddddd | Renvoie la date en abrégé | Format (Date,"ddddd") | 01/04/2008 |
dddddd | Renvoie la date complète de la date passée en paramètre | Format (Date,"dddddd") | mardi 1 avril 2008 |
w | Renvoie le jour de la semaine de la date passée en paramètre | Format (Date,"w") | 3 |
ww | Renvoie le numéro de la semaine de la date passée en paramètre | Format (Date,"ww") | 14 |
m | Renvoie le mois de la date passée en paramètre | Format (Date,"m") | 4 |
mm | Renvoie le mois (sur deux chiffres) de la date passée en paramètre | Format (Date,"mm") | 04 |
mmm | Renvoie le mois (abrégé) de la date passée en paramètre | Format (Date,"mmm") | avr |
mmmm | Renvoie le mois (en toutes lettres) de la date passée en paramètre | Format (Date,"mmmm") | avril |
q | Renvoie le numéro du trimestre de la date passée en paramètre | Format (Date,"q") | 2 |
yy | Renvoie l'année (sur deux chiffres) de la date passée en paramètre | Format (Date,"yy") | 08 |
yyyy | Renvoie l'année (sur quatre chiffres) de la date passée en paramètre | Format (Date,"yyyy") | 2008 |
h | Renvoie l'heure de l'heure complète passée en paramètre | Format (Time,"h") | 9 |
hh | Renvoie l'heure (sur deux chiffres) de l'heure complète passée en paramètre | Format (Time,"hh") | 09 |
n | Renvoie les minutes de l'heure complète passée en paramètre | Format (Time,"n") | 5 |
nn | Renvoie les minutes (sur deux chiffres) de l'heure complète passée en paramètre | Format (Time,"nn") | 05 |
s | Renvoie les secondes de l'heure complète passée en paramètre | Format (Time,"s") | 9 |
ss | Renvoie les secondes (sur deux chiffres) de l'heure complète passée en paramètre | Format (Time,"ss") | 09 |
AM/PM ou am/pm | Renvoie l'heure au format 12 heures avec indicateur am ou pm de l'heure complète passée en paramètre | Format (Time,"hh:mm am/pm") | 09:05 am |
Chaîne de caractères :
Format | Détail | Code | Résultat |
---|---|---|---|
> | Affiche la chaîne de caractères passée en paramètre en majuscule | Format ("Hello",">") | HELLO |
< | Affiche la chaîne de caractères passée en paramètre en minuscule | Format ("Hello","<") | hello |
@ | Espace réservé à un caractère. Affichage d'un caractère ou d'un espace. Si la chaîne contient un caractère à la position occupée par le symbole @ dans l'expression de mise en forme, ce caractère est affiché ; sinon, un espace est affiché à cet emplacement | Format ("Hello","@@@@@@") | Hello -> place un espace avant le H |
& | Espace réservé à un caractère. Affichage d'un caractère ou de rien d'autre. Si la chaîne contient un caractère à la position occupée par le signe & ce caractère est affiché ; sinon, rien n'est affiché | Format ("Hello","&&#") | He#llo |
! | Remplissage des espaces réservés de gauche à droite. Par défaut, le remplissage s'effectue de droite à gauche. | Format ("Hello","!&&&&") | ello |
numérique :
Format | Détail | Code | Résultat |
---|---|---|---|
0 | Espace réservé à un chiffre. Affichage d'un chiffre ou d'un zéro. Si l'expression contient un chiffre à la position occupée par le 0 dans la chaîne de mise en forme, il est affiché ; sinon un zéro est affiché à cet emplacement. | Format(44.92, "000.0") | 044,9 |
# | Espace réservé à un chiffre. Affichage d'un chiffre ou d'aucun caractère. Si l'expression mise en forme contient un chiffre à la position occupée par le signe # dans la chaîne de mise en forme, il est affiché ; sinon, rien n'est affiché à cet emplacement. | Format(44.92, "#0.0") | 44,9 |
% | Espace réservé au signe pourcentage. L'expression est multipliée par 100. Le signe pourcentage (%) est inséré à la position où il apparaît dans la chaîne de mise en forme. | Format(44.92, "#0.0%") | 4492,0% |
Je vous invite à consulter le tutoriel de Maxence HUBICHE sur les dates : Les Fonctions Date/Heure en VBA
III-D-2. Fonction MsgBox▲
Cette fonction permet d'afficher à l'écran une boîte de message signalant
un message à l'utilisateur comme fin de traitement, erreur de saisie, etc. ou
pour attendre une réponse de celui-ci comme le choix entre Oui ou Non. La
fenêtre la plus connue est celle qui s'affiche lorsque vous fermer une application
sans l'enregistrer, une fenêtre s'ouvre demandant si vous voulez enregistrer le
document avant de le fermer, 3 choix s'offrent à vous Oui, Non ou Annuler.
Voici la syntaxe :
MsgBox(prompt[, buttons] [, title] [, helpfile, context])
La fonction possède plusieurs paramètres permettant de personnaliser le message
affiché, seul ce qui n'est pas entre [] est obligatoire.
prompt -> correspond au message qui se situe dans le corps du message.
peut contenir une chaîne de caractères et/ou Variable et/ou Constante.
buttons -> constante vb permettant de définir le type de boutons qui seront
affichés sur le message, l'icône du message et le bouton qui recevra le Focus
à l'ouverture (bouton par défaut) :
- vbOKOnly ==> Affiche le bouton OK uniquement.
- vbOKCancel ==> Affiche les boutons OK et Annuler.
- vbAbortRetryIgnore ==> Affiche le bouton Abandonner, Réessayer et Ignorer.
- vbYesNoCancel ==> Affiche les boutons Oui, Non et Annuler.
- vbYesNo ==> Affiche les boutons Oui et Non.
- vbRetryCancel ==> Affiche les boutons Réessayer et Annuler.
- vbCritical ==> Affiche l'icône Message critique.
- vbQuestion ==> Affiche l'icône Requête d'avertissement.
- vbExclamation ==> Affiche l'icône Message d'avertissement.
- vbInformation ==> Affiche l'icône Message d'information.
- vbDefaultButton1 ==> Le premier bouton est le bouton par défaut.
- vbDefaultButton2 ==> Le deuxième bouton est le bouton par défaut.
- vbDefaultButton3 ==> Le troisième bouton est le bouton par défaut.
- vbDefaultButton4 ==> Le quatrième bouton est le bouton par défaut.
- vbApplicationModal ==> Boîte de dialogue modale. L'utilisateur doit répondre au message affiché dans la zone de message avant de pouvoir continuer de travailler dans l'application en cours.
- vbSystemModal ==> Modal système. Toutes les applications sont interrompues jusqu'à ce que l'utilisateur réponde au message affiché dans la zone de message.
- vbMsgBoxHelpButton ==> Ajoute le bouton Aide à la zone de message.
- VbMsgBoxSetForeground ==> Indique la fenêtre de zone de message comme fenêtre de premier plan.
- vbMsgBoxRight ==> Le teste est aligné à droite.
- vbMsgBoxRtlReading ==> Indique que le texte doit apparaître de droite à gauche sur les systèmes hébraïques et arabes.
- vbOK ==> Bouton OK
- vbCancel ==> Bouton Annuler
- vbAbort ==> Bouton Abandonner
- vbRetry ==> Bouton Répéter
- vbIgnore ==> Bouton Ignorer
- vbYes ==> Bouton Oui
- vbNo ==> Bouton Non
Prenons en exemple le souhait de poser la question à l'utilisateur
avant de réaliser une opération critique sur des données :
MsgBox
"Voulez-vous réellement vider ce dossier ?"
, vbYesNo
+
vbInformation
, "ATTENTION"
Ce code vous affiche cette boîte de message :
Maintenant nous allons récupérer le résultat de l'utilisateur :
If
MsgBox
(
"Voulez-vous réellement vider ce dossier ?"
, _
vbYesNo
+
vbInformation
, "ATTENTION"
) =
vbYes
Then
'Code à réaliser car l'utilisateur à répondu Yes
End
If
Le Code ci-dessus demande à l'utilisateur si l'action est à réaliser ou non, si l'utilisateur répond Yes alors nous exécutons le code, s'il répond Non nous sortons du test et nous ne faisons rien.
Pour mettre le message sur plusieurs lignes vous pouvez utiliser la constante
vbCr ou bien le code ascii Chr(13).
Voici un exemple :
MsgBox
"Première ligne"
&
vbCr
&
"Seconde ligne"
&
Chr
(
13
) &
"Troisième ligne"
Je vous invite à consulter les tutoriels de Thierry GASPERMENT :
Des textes formatés et cliquables pour une MsgBox avancée sur Access
, de Fabrice CONSTANS :Générateur de MsgBox toutes versions et celui de Fred (fring) :
VBA EXCEL : La MsgBox décortiquée
III-D-3. Fonction InputBox▲
La différence entre la MsgBox et l'InputBox réside que dans l'InputBox on
attend une information que l'utilisateur doit saisir dans la zone prévue à cet effet.
Le retour de cette saisie est de Type String
InputBox(prompt[, title] [, default] [, xpos] [, ypos] [, helpfile, context])
Tout comme la MsgBox seul ce qui n'est pas entre [] est obligatoire.
Lors de l'appel de l'InputBox vous devez assigner une variable pour le
retour de celle-ci.
Exemple de code :
Dim
strRetourInput As
String
strRetourInput =
InputBox
(
"Bonjour,"
&
vbCr
&
"Quel âge avez-vous ?"
, "Demande d'âge"
)
strRetourInput aura pour valeur la saisie de l'utilisateur.
Il est possible de mettre une valeur par défaut lors de l'ouverture de
l'InputBox.
Dim
strRetourInput As
String
strRetourInput =
InputBox
(
"Bonjour,"
&
vbCr
&
"Quel âge avez-vous ?"
, "Demande d'âge"
, 0
)
Si l'utilisateur clic sur Annuler la chaîne de caractères a pour
retour une chaîne vide, il vous suffit de la tester.
Exemple de code :
Sub
EssaisCode
(
)
'Déclaration variable
Dim
strRetourInput As
String
'Affichage InputBox
strRetourInput =
InputBox
(
"Bonjour,"
&
vbCr
&
"Quel âge avez-vous ?"
, "Demande d'âge"
, 0
)
'Test si chaîne Vide
If
strRetourInput =
""
Then
'Chaîne Vide
MsgBox
"Action annulée par l'utilisateur ou bien aucune saisie de l'utilisateur."
Else
'Chaîne non vide
MsgBox
strRetourInput
End
If
End
Sub
III-E. Les tests▲
La clé dans un code est le test des différentes variables ou retour de différentes fonctions.
III-E-1. If ... Then▲
Cette instruction permet de guider le code selon la condition passée en paramètre.
Syntaxe :
If condition Then Instruction
Interprétation du code : Si la condition est vraie alors on exécute l'instruction.
Exemple :
Sub
EssaisCode
(
)
Const
blnTest As
Boolean
=
True
If
blnTest =
True
Then
MsgBox
"La valeur est vraie"
End
Sub
Cette syntaxe est valable que si vous exécutez une instruction après le Then, si vous voulez exécuter un ensemble d'instructions vous devrez exécuter cette syntaxe :
If
Condition Then
'Instruction si condition Vraie
Else
'Instruction si condition Fausse
End
If
Interprétation du code : Si la condition est vraie on exécute le code placé derrière le Then, par contre si la condition est fausse on exécute le code placé derrière le Else, une fois les instructions réalisées le code se place sur le End If et continue jusqu'à la fin de la procédure.
Une autre variante existe, celle-ci consiste à conditionner le Else, c'est à dire si l'instruction est fausse on vient tester la seconde condition.
If
Condition Then
'Instruction si condition Vraie
ElseIf
Condition2 Then
'Instruction si condition Fausse
End
If
Interprétation : Si la condition est vraie on exécute le code placé derrière le Then, par contre si la condition est fausse on vient tester la seconde condition, si celle-ci est vraie on exécute le code placé derrière le second Then, une fois les instructions réalisées le code se place sur le End If et continue jusqu'à la fin de la procédure.
If
Condition Then
'Instruction si condition Vraie
ElseIf
Condition2 Then
'Instruction si condition Fausse
Else
'Instruction si aucune condition n'est vraie
End
If
Interprétation : Si la condition est vraie on exécute le code placé derrière le Then, par contre si la condition est fausse on vient tester la seconde condition, si celle-ci est vraie on exécute le code placé derrière le second Then, par contre si celle-ci est également fausse on exécute le code situé derrière le Else, une fois les instructions réalisées le code se place sur le End If et continue jusqu'à la fin de la procédure.
Il vous est possible d'imbriquer plusieurs If les uns derrière les autres.
If
Condition Then
'Instruction si Condition est vraie
If
Condition2 Then
'Instruction si Condition est vraie et Condition2 est vraie
Else
'Instruction si Condition est vraie et Condition2 est fausse
End
If
Else
'Instruction si Condition est fausse
End
If
III-E-2. Select Case▲
Cette instruction peut s'avérer intéressante pour éviter l'imbrication d'une
multitude de IF. Pour cela nous testons une Condition et guidons le code en fonction
des différents tests.
Syntaxe :
Select
Case
Condition
Case
1
'Instruction si Condition = 1
Case
2
'Instruction si Condition = 2
Case
3
'Instruction si Condition = 3
Case
4
'Instruction si Condition = 4
Case
Else
'Instruction si Condition n'est égale avec aucun test
End
Select
Interprétation : Test de la valeur de Condition, les différents tests sont parcourus dès que la condition est égale à un test le code exécute les instructions qui suivent le Case et sort de la boucle de test pour se positionner sur le End Select, si Condition n'est égale à aucune valeur alors nous exécutons l'instruction derrière le Else, une fois ces instructions terminées le code se positionne au niveau du End Select et finit les instructions jusqu'à la fin de la procédure.
Vous pouvez tester des plages pour guider le code.
Syntaxe :
Select
Case
Condition
Case
Is
<=
10
'Instruction si Condition est strictement inférieure ou égale à 10
Case
Is
<=
20
'Instruction si Condition est strictement inférieure ou égale à 20
Case
Is
<=
30
'Instruction si Condition est strictement inférieure ou égale à 30
Case
Is
<=
40
'Instruction si Condition est strictement inférieure ou égale à 40
Case
Else
'Instruction si Condition n'est égale avec aucun test
End
Select
Interprétation : Test de la valeur de Condition, les différents tests sont parcourus dès que la condition est égale à un test le code exécute les instructions qui suivent le Case et sort de la boucle de test pour se positionner sur le End Select, si Condition n'est égale à aucune valeur alors nous exécutons l'instruction derrière le Else, une fois ces instructions terminées le code se positionne au niveau du End Select et finit les instructions jusqu'à la fin de la procédure.
Vous pouvez également mettre plusieurs conditions sur un Case ou définir
un plage.
Syntaxe :
Select
Case
Condition
Case
Is
<=
10
'Instruction si Condition est strictement inférieure ou égale à 10
Case
Is
<=
20
'Instruction si Condition est strictement inférieure ou égale à 20
Case
30
, 31
, 32
, 33
'Instruction si Condition = 30, 31, 32 ou 33
Case
34
To
40
'Instruction si Condition est comprise entre 34 et 40
Case
Else
'Instruction si Condition n'est égale avec aucun test
End
Select
Interprétation : Test de la valeur de Condition, les différents tests sont parcourus dès que la condition est égale à un test le code exécute les instructions qui suivent le Case et sort de la boucle de test pour se positionner sur le End Select, pour les deux derniers Case; on teste si Condition égale 30, 31, 32, ou 33, en ce qui concerne le dernier Case on teste si Condition est dans la fourchette, si Condition n'est égale à aucune valeur alors nous exécutons l'instruction derrière le Else, une fois ces instructions terminées le code se positionne au niveau du End Select et finit les instructions jusqu'à la fin de la procédure.
III-F. Les Boucles▲
Comme son nom l'indique ces instructions permettent de réaliser des boucles dans le code,
plusieurs types de boucles existent :
Je vous invite à consulter le tutoriel de Michel TANGUY : La gestion des boucles dans Excel
III-F-1. For ... To ... Next▲
Cette boucle permet d'exécuter le code plusieurs fois selon le nombre que l'on a indiqué en paramètre.
Syntaxe :
For
i =
1
To
4
MaVar =
MaVar +
10
Next
i
Interprétation : On définit une variable i qui correspond au compteur de la boucle et nous passons en paramètre l'exécution de 1 jusqu'à 4 fois la boucle, à chaque passage nous additionnons 10 à la variable MaVar.
Vous pouvez définir le pas d'incrémentation du Compteur, par défaut le pas est de 1 mais
si vous souhaitez incrémenter le compteur de 3 en 3 il faut ajouter Step.
Syntaxe :
For
i =
1
To
30
Step
3
MaVar =
MaVar +
10
Next
i
Interprétation : On définit une variable i qui correspond au compteur de la boucle et nous passons en paramètre l'exécution de 1 jusqu'à 30 mais avec un pas de 3, c'est à dire le compteur ira de 3 en 3 jusqu'à 30, à chaque passage nous additionnons 10 à la variable MaVar.
Il vous est également possible de sortir de la boucle avant que le compteur arrive à sa valeur
maximale, pour cela utiliser l'instruction Exit For.
Syntaxe :
For
i =
1
To
4
MaVar =
MaVar +
10
If
MaVar =
20
Then
Exit
For
Next
i
Interprétation : On définit une variable i qui correspond au compteur de la boucle et nous passons en paramètre l'exécution de 1 jusqu'à 4 fois la boucle, à chaque passage nous additionnons 10 à la variable MaVar, un test est réalisé si MaVar correspond à la valeur 20 on sort de la boucle même si celle-ci n'a pas été réalisée 4 fois.
Il vous est possible d'imbriquer plusieurs Boucles dans une Boucle, attention à bien ficeler votre code pour ne pas tourner en boucle sans pouvoir sortir de celles-ci.
III-F-2. For Each ... Next▲
Cette boucle permet de parcourir tous les éléments d'une collection ou tableau. En exemple elle permet de parcourir l'ensemble d'E-mails dans la boîte de réception et de renvoyer dans une boîte de message les noms des expéditeurs.
Sub
EssaisCode
(
)
'---------------------------------------------------------------------------------------
' Procédure : EssaisCode
' Auteur : Dolphy35
' Site : http://dolphy35.developpez.com
' Détail : Permet de lister les noms d'expéditeur des Mails présent dans la
' boîte de réception.
'---------------------------------------------------------------------------------------
'
'Déclarations
Dim
olApp As
Outlook.Application
Dim
olMail As
Outlook.MailItem
Dim
mapDossier As
Outlook.MAPIFolder
Dim
strResultat As
String
'Instancies
Set
olApp =
Outlook.Application
Set
mapDossier =
olApp.GetNamespace
(
"MAPI"
).GetDefaultFolder
(
olFolderInbox)
'Boucle parcourant les Emails de la boîte de réception
For
Each
olMail In
mapDossier.Items
strResultat =
strResultat &
olMail.SenderName
&
vbCr
Next
'Affichage du résultat
MsgBox
strResultat, , "Liste de Noms des Mails reçus"
End
Sub
III-F-3. Do While ... Loop▲
Cette instruction permet de parcourir la boucle tant que la valeur testée est vraie.
Première syntaxe :
Dim
bytCompteur As
Byte
bytCompteur =
0
Do
While
bytCompteur <
4
bytCompteur =
bytCompteur +
1
Loop
MsgBox
bytCompteur
Interprétation : On déclare et charge une variable avec la valeur 0 puis on teste cette variable et
on boucle tant que celle-ci est inférieure à 4.
Deuxième Syntaxe :
Dim
bytCompteur As
Byte
bytCompteur =
0
Do
bytCompteur =
bytCompteur +
1
Loop
While
bytCompteur <
4
MsgBox
bytCompteur
Interprétation : On déclare et charge une variable avec la valeur 0 puis on teste cette variable et on boucle tant que celle-ci est inférieure à 4.
La différence entre les deux syntaxes réside sur le passage ou non dans la boucle avant le test,
par exemple si strCompteur est supérieur à 4 dans le premier cas on ne rentre pas dans la boucle
par contre le second fait que l'on rentre dans la boucle et on teste la condition pour reboucler
si celle-ci est toujours vraie.
Pour sortir d'une de ces boucles utiliser l'instruction Exit Do
III-F-4. Do Until ... Loop▲
Cette instruction fonctionne comme la précédente, la différence est sur le test de la condition. La précédente boucle tant que la condition est vraie alors que celle-ci boucle tant que la condition n'est pas vraie.
Dim
bytCompteur As
Byte
bytCompteur =
0
Do
Until
bytCompteur >
4
bytCompteur =
bytCompteur +
1
Loop
MsgBox
bytCompteur
Dim
bytCompteur As
Byte
bytCompteur =
0
Do
bytCompteur =
bytCompteur +
1
Loop
Until
bytCompteur >
4
MsgBox
bytCompteur
III-F-5. While ... Wend▲
Cette instruction permet de parcourir la boucle tant que la condition n'est pas vraie.
Celle-ci est moins souple que l'instruction Do ... Loop.
Syntaxe :
Dim
bytCompteur As
Byte
bytCompteur =
0
While
bytCompteur <
4
bytCompteur =
bytCompteur +
1
Wend
MsgBox
bytCompteur
III-G. Les références▲
Dans certain cas il vous sera nécessaire d'ajouter une référence dans votre projet,
pour l'ajouter ouvrez la fenêtre de références : menu Outils puis sélectionnez
Références...
La fenêtre suivante s'ouvre :
Toutes les lignes cochées correspondent aux références de votre projet. Toutes les
références indispensables à votre projet ne peuvent être décochées. Si vous essayez
de décocher la référence Microsoft Outlook 12.0 Object Library vous verrez
apparaître le message suivant :
Si vous essayez d'exécuter un code nécessitant une référence que vous n'avez pas cochée,
vous verrez apparaître le message suivant lors de la compilation de votre Projet :
Pour exemple copier le code suivant dans un nouveau Module :
Sub
refNok
(
)
'---------------------------------------------------------------------------------------
' Procédure : refNok
' Auteur : Dolphy35 http://dolphy35.developpez.com
' Date : 27/03/2008
' Détail : Code permettant de créer un fichier texte et d'y écrire une ligne
'---------------------------------------------------------------------------------------
'
'Déclarations des variables
Dim
oFSO As
Scripting.FileSystemObject
Dim
oTXT As
Scripting.TextStream
'Instancie les Objets pour création fichier Texte
Set
oFSO =
CreateObject
(
"Scripting.FileSystemObject"
)
Set
oTXT =
oFSO.CreateTextFile
(
"C:\Test.txt"
, True
)
'Accès au nouveau fichier texte
With
oTXT
'Ajout d'une ligne et écriture
.WriteLine
"Bonjour, nous sommes le "
&
Date
'Fermeture du fichier
.Close
End
With
'Vide les instances
Set
oTXT =
Nothing
Set
oFSO =
Nothing
End
Sub
Lorsque vous compilez le module l'erreur précédente s'affiche.
Compiler => Menu Débogage puis sélectionnez Compiler
Pour que ce code fonctionne il vous faut ajouter la référence Microsoft
Scripting Runtime depuis la fenêtre de références. Maintenant aucune erreur
n'est relevée lors de la compilation, il ne vous reste plus qu'à exécuter le code.
Celui-ci va créer un fichier texte sous la racine C:\ appelé Test.txt.
IV. Quel type de Procédure choisir▲
Pour créer votre première procédure je vous invite à créer un nouveau Module :
-> Menu Insertion -> Nouveau Module
Un nouveau Module vient de faire son apparition dans la fenêtre d'explorateur de projets,
il a pour nom Module1. Vous pouvez modifier son nom en le sélectionnant et changer le nom
depuis la fenêtre de propriétés.
IV-A. Instruction Sub▲
Permet de déclarer le nom et les arguments d'un ensemble d'instructions formant le code et
le corps de la procédure.
Syntaxe :
[Private | Public | Friend] [Static] Sub Nom [(arguments)]
Code
End Sub
Portée l'instruction Sub :
Elément | Détail |
---|---|
Private | Définit que la procédure n'est accessible que depuis le module où elle est déclarée. Cet élément est facultatif |
Public | Définit que la Procédure est accessible depuis l'ensemble des modules du Projet. Cet élément est facultatif |
Friend | Définit que la Procédure est accessible depuis l'ensemble des modules du Projet. Cet élément est facultatif et n'est utilisé que dans un module de Classe |
Static | Définit que les variables déclarées de ce module sont conservées entre deux exécutions tant que l'application est ouverte. Cet élément est facultatif |
Eléments de l'instruction Sub :
Eléments | Détails |
---|---|
Nom | Correspond au nom donné à l'instruction Sub. Les caractères spéciaux, mots-clés réservés d'Office et les espaces ne sont pas acceptés. Seul le underscore ( _ ) est autorisé |
Arguments | Liste d'arguments (variables) qui sont passés à la procédure en tant que paramètres lors de leurs appels. Ces arguments sont facultatifs. |
Code | Correspond à une suite d'instructions VBA permettant de définir le code de cette procédure. |
End Sub | Correspond à la fin de la procédure. |
IV-A-1. Les arguments d'une instruction Sub▲
Lors de la déclaration d'une instruction Sub on peut lui donner un ou plusieurs arguments,
dans le cas de plusieurs ils seront séparés par des virgules, permettant un bon fonctionnement
de la procédure.
Syntaxe :
[Optional] [ByVal | ByRef] [ParamArray] Nom [( )] [As type] [= ValeurDéfaut]
Description des arguments :
Arguments | Détails |
---|---|
Optional | Définit que l'argument est optionnel donc facultatif lors de l'appel de la procédure. |
ByVal | Définit que l'argument est passé en tant que valeur à la procédure, la procédure qui reçoit cet argument ne peut modifier son contenu elle ne la reçoit qu'en lecture seule. |
ByRef | Définit que l'argument est passé en tant que référence à la procédure, la procédure qui reçoit cet argument peut modifier son contenu elle la reçoit en lecture/écriture. |
Nom | Correspond au nom de la variable passée en argument de la procédure. |
Type | Correspond au type de la variable passée en procédure (String, Integer, Byte, etc.) |
ValeurDéfaut | Toute constante ou expression constante. Valide uniquement pour les paramètres Optional. S'il s'agit d'un type Object, seul Nothing peut être explicitement indiqué en valeur par défaut. |
Exemple de Procédure dans Outlook :
Private
Sub
Application_ItemSend
(
ByVal
Item As
Object, Cancel As
Boolean
)
'---------------------------------------------------------------------------------------
' Procédure : Application_ItemSend
' Auteur : Dolphy35
' Site : http://dolphy35.developpez.com
' Détail : Permet de tester si présence d'un sujet avant l'envoi d'un Mail
'---------------------------------------------------------------------------------------
'
'Test si c'est un Email
If
Not
Item.Class
=
olMail Then
Exit
Sub
'Déclaration de la variable en tant que Mail
Dim
monMail As
MailItem
'Instancie L'élément à la variable Mail
Set
monMail =
Item
'Test si le sujet n'est pas vide
If
monMail.Subject
=
""
Then
'Message si sujet vide
MsgBox
"Veuillez saisir un Sujet à votre E-Mail"
'Annule l'envoi
Cancel =
True
End
If
End
Sub
Il est possible de sortir de la procédure Sub avant qu'elle ne soit entièrement exécutée en utilisant l'instruction Exit Sub.
IV-B. L'instruction Function▲
Permet de déclarer le nom et les arguments d'un ensemble d'instructions formant le code et
le corps de la procédure.
Syntaxe :
[Public | Private | Friend] [Static] Function Nom [(Arguments)] [As type]
Code
End Function
La portée de la procédure et les arguments sont identiques entre les instructions Sub et
Function.
Ce qui diffère entre les deux se trouve au niveau de leurs appels au sein d'une autre
procédure, la Sub ne peut être écrite à droite d'une expression, par contre une Function peut
l'être comme Chr ou autre. La notion de fonction est plus visible dans Excel car celle-ci
peut être appelée depuis la feuille de calcul en tant que fonction intégrée d'Excel.
Voici un exemple de procédure Function :
Function
EssaisCode
(
) As
String
'---------------------------------------------------------------------------------------
' Procédure : EssaisCode
' Auteur : Dolphy35
' Site : http://dolphy35.developpez.com
' Détail : Permet de lister les noms d'expéditeurs des Mails présents dans la
' boîte de réception.
'---------------------------------------------------------------------------------------
'
'Déclarations
Dim
olApp As
Outlook.Application
Dim
olMail As
Outlook.MailItem
Dim
mapDossier As
Outlook.MAPIFolder
Dim
strResultat As
String
'Instancies
Set
olApp =
Outlook.Application
Set
mapDossier =
olApp.GetNamespace
(
"MAPI"
).GetDefaultFolder
(
olFolderInbox)
'Boucle parcourant les Emails de la boîte de réception
For
Each
olMail In
mapDossier.Items
EssaisCode =
EssaisCode &
olMail.SenderName
&
vbCr
Next
End
Function
Toute seule cette procédure ne sert à rien, il faut donc l'appeler depuis une autre procédure :
Sub
essais
(
)
MsgBox
EssaisCode
End
Sub
Ce code renvoi dans une boîte de message le nom des expéditeurs des Emails
contenus dans votre boîte de réception.
V. ThisOutlookSession▲
Dans l'explorateur de Projet vous pouvez constater la présence d'un Module ayant pour nom ThisOutlookSession, ceci est un Module de classe correspondant à l'instance de l'application Outlook ouverte. Vous y trouverez toutes les propriétés, événements et méthodes liés à cette instance.
V-A. Evénements▲
Nous n'allons pas énumérer tous les événements disponibles dans ce Module de classe,
pour connaître l'ensemble des événements, sélectionnez le Module de classe ThisOutlookSession
puis dans la première liste déroulante (Général) située en haut de la fenêtre de visualisation sélectionnez
Application
La procédure ItemSend s'ajoute automatiquement au Module de classe. Il vous est
possible d'en sélectionner une autre dans la seconde liste (Déclarations) située à côté,
vous y trouvez également la liste complète des événements disponibles pour ce Module de
classe.
Maintenant nous allons développer les plus utilisées.
V-A-1. AdvancedSearchComplete▲
Cet événement sera activé lorsque la méthode AdvancedSearch sera terminée, cette procédure renvoie l'objet du résultat
de la méthode.
Le code suivant permet de faire une recherche sur le sujet des Emails et renvoie le nom de l'expéditeur si le sujet correspond
à 'Salut'.
Macro permettant de lancer la recherche :
Public
blnStopSearch As
Boolean
Sub
Recherche
(
)
'---------------------------------------------------------------------------------------
' Procédure : Recherche
' Auteur : Dolphy35 - http://dolphy35.developpez.com/
' Date : 21/04/2008
' Détail : Effectue une recherche par la méthode AdvancedSearch
'---------------------------------------------------------------------------------------
'
'Déclaration de l'objet et de la variable
Dim
ObjSearch As
Outlook.Search
Dim
i As
Integer
'Initialisation du boolean
blnStopSearch =
False
'Déclaration et chargement des constantes, pour le filtre et le dossier de recherche
Const
strFiltre As
String
=
"urn:schemas:mailheader:subject = 'Salut'"
Const
strDossier As
String
=
"Inbox"
'Instancie l'objet à la méthode AdvancedSearch
Set
ObjSearch =
Application.AdvancedSearch
(
strDossier, strFiltre)
'Boucle tant que AdvancedSearch n'a pas fini sa recherche, déclenche l'événement AdvancedSearchComplete
While
blnStopSearch =
False
DoEvents
Wend
End
Sub
Private
Sub
Application_AdvancedSearchComplete
(
ByVal
SearchObject As
Search)
'---------------------------------------------------------------------------------------
' Procédure : Application_AdvancedSearchComplete
' Auteur : Dolphy35 - http://dolphy35.developpez.com/
' Date : 21/04/2008
' Détail : utilise l'événement AdvancedSearchComplete suite à une recherche
'---------------------------------------------------------------------------------------
'
'Déclaration de l'objet
Dim
objResultat As
Outlook.Results
'Instancie à l'objet le résultat de la recherche
Set
objResultat =
SearchObject.Results
If
objResultat.Count
>
0
Then
'Boucle en fonction du nombre d'occurrences trouvées
For
i =
1
To
objResultat.Count
'Affichage du résultat dans une msgbox
MsgBox
objResultat.Item
(
i).SenderName
Next
Else
MsgBox
"La recherche n'a trouvé aucune occurrence"
End
If
'Passage à True de la Variable pour stopper la boucle
blnStopSearch =
True
End
Sub
V-A-2. AdvancedSearchStopped▲
Cet événement s'exécute lorsque la méthode Stop d'un objet Search est exécutée.
Le code suivant lance une recherche sur le sujet dans la boîte de réception, la méthode Stop est exécutée
pour l'exemple :
Sub
StopSearch
(
)
'---------------------------------------------------------------------------------------
' Procédure : StopSearch
' Auteur : Dolphy35 - http://dolphy35.developpez.com/
' Date : 21/04/2008
' Détail : Réalise une recherche et exécute la méthode Stop de l'objet Search
'---------------------------------------------------------------------------------------
'
'Déclaration de l'objet
Dim
objSearch As
Outlook.Search
'Déclaration des constantes et chargement
Const
strDossier As
String
=
"Inbox"
Const
strFiltre As
String
=
"urn:schemas:mailheader:subject = 'Salut"
'Instancie l'objet Search
Set
objSearch =
Application.AdvancedSearch
(
strDossier, strFilter)
'Méthode Stop de l'objet Search
objSearch.Stop
End
Sub
Private
Sub
Application_AdvancedSearchStopped
(
ByVal
SearchObject As
Search)
'---------------------------------------------------------------------------------------
' Procédure : Application_AdvancedSearchStopped
' Auteur : Dolphy35 - http://dolphy35.developpez.com/
' Date : 21/04/2008
' Détail : Survient lors de l'exécution de la méthode Stop de l'objet Search
'---------------------------------------------------------------------------------------
'
'Affichage d'un message lors de la levée de l'événement
MsgBox
"La méthode Stop de l'objet Search a été exécutée"
End
Sub
V-A-3. AttachmentContextMenuDisplay▲
Evénement déclenché avant l'ouverture du menu contextuel correspondant au jeu de collection de
pièces jointes.
L'exemple suivant permet de créer un bouton dans le menu contextuel du jeu de sélection des pièces jointes
d'un E-mail ouvert et affecte une macro à ce bouton. La macro affectée permet de récupérer le nom et la taille
en octets de chaque pièce jointe du jeu de sélection de pièces jointes et affiche le résultat dans une boîte de
message. Le nom de la macro : InfosPJ
'Déclare l'objet comme jeu d'objets correspondant aux pièces jointes sélectionnées
Dim
objAttachments As
AttachmentSelection
Private
Sub
Application_AttachmentContextMenuDisplay
(
_
ByVal
CommandBar As
Office.CommandBar
, _
ByVal
Attachments As
AttachmentSelection)
'---------------------------------------------------------------------------------------
' Procédure : Application_AttachmentContextMenuDisplay
' Auteur : Dolphy35 - http://dolphy35.developpez.com/
' Date : 24/04/2008
' Détail : Création d'un contrôle dans le menu contextuel des pièces jointes et
' affecte une macro
'---------------------------------------------------------------------------------------
'
'Déclaration de l'objet en tant que bouton de commande
Dim
objButton As
CommandBarButton
'Instancie à l'objet la sélection des pièces jointes
Set
objAttachments =
Attachments
'Instancie l'objet en tant que nous nouveau contrôle : Bouton
Set
objButton =
CommandBar.Controls.Add
(
_
msoControlButton, , , , True
)
'Paramétrage du nouveau bouton
With
objButton
.Style
=
msoButtonIconAndCaption 'Icône + commentaire
.Caption
=
"Test"
'Commentaire
.FaceId
=
355
'ID de l'icône du bouton
.OnAction
=
"Projet 1.ThisOutlookSession.InfosPJ"
'Affectation de la macro au bouton lors du clic
End
With
End
Sub
Sub
InfosPJ
(
)
'---------------------------------------------------------------------------------------
' Procédure : msgtest
' Auteur : Dolphy35 - http://dolphy35.developpez.com/
' Date : 24/04/2008
' Détail : Affiche dans une boite de dialogue le nom des pièces jointes
' sélectionnées ainsi que la taille en octets
'---------------------------------------------------------------------------------------
'
'Déclaration des objets et variables
Dim
objAttachment As
Attachment
Dim
strTemp As
String
'initialisation de la variable
strTemp =
""
'boucle permettant de sortir les pièces jointes du jeu de sélection des pièces jointes
For
Each
objAttachment In
objAttachments
'Objet pièce jointe
With
objAttachment
strTemp =
"Nom : "
&
.FileName
'nom de la pièce jointe
strTemp =
strTemp &
vbCr
&
"Taille : "
&
.Size
&
" octets"
'taille de la pièce jointe
End
With
'affichage des infos de la pièce jointe contenus dans la variable.
MsgBox
strTemp
Next
End
Sub
Attention cet événement n'est disponible que dans la version 2007 d'Outlook
V-A-4. FolderContextMenuDisplay▲
Cet événement intervient avant l'affichage du menu contextuel d'un dossier, c'est à dire lors d'un clic droit sur un dossier. L'exemple suivant est simple : nous allons créer un nouveau contrôle dans le menu contextuel qui lors d'un clic exécutera une macro. Celle-ci affiche dans une boîte de message le nom du dossier.
Dim
strSelection As
String
Private
Sub
Application_FolderContextMenuDisplay
(
_
ByVal
CommandBar As
Office.CommandBar
, _
ByVal
fldFolder As
Folder)
Dim
objButton As
CommandBarButton
Dim
intButtonIndex As
Integer
Dim
intCounter As
Integer
Set
objButton =
CommandBar.Controls.Add
(
_
msoControlButton, , , , True
)
With
objButton
.Style
=
msoButtonIconAndCaption
.Caption
=
"Infos sur le Dossier"
.FaceId
=
463
.OnAction
=
"Projet 1.ThisOutlookSession.InfosDossier"
End
With
strSelection =
fldFolder.Name
End
Sub
Sub
InfosDossier
(
)
MsgBox
strSelection
End
Sub
Attention cet événement n'est disponible que dans la version 2007 d'Outlook
V-A-5. ItemContextMenuDisplay▲
Cet événement est exécuté avant qu'un menu contextuel d'un élément s'affiche. Dans l'exemple suivant nous allons créer un nouveau contrôle du menu contextuel et lui affecter une macro, celle-ci retournera le nom et la taille des pièces jointes dans une boîte de message.
Private
Sub
Application_ItemContextMenuDisplay
(
_
ByVal
CommandBar As
Office.CommandBar
, _
ByVal
Selection As
Selection)
Dim
objButton As
CommandBarButton
Dim
intButtonIndex As
Integer
Dim
intCounter As
Integer
'Test si 1 seul mail est sélectionné
If
Selection.Count
=
1
Then
'Test si la sélection correspond à un E-mail
If
Selection.Item
(
1
).Class
=
olMail Then
Set
objButton =
CommandBar.Controls.Add
(
_
msoControlButton, , , , True
)
With
objButton
.Style
=
msoButtonIconAndCaption
.Caption
=
"Infos sur le Mail"
.FaceId
=
463
.OnAction
=
"Projet 1.ThisOutlookSession.InfosMail"
End
With
End
If
End
If
End
Sub
Voici la macro exécutée en cliquant sur le nouveau contrôle :
Sub
InfosMail
(
)
'---------------------------------------------------------------------------------------
' Procédure : InfosMail
' Auteur : Dolphy35 - http://dolphy35.developpez.com/
' Date : 25/04/2008
' Détail : Macro permettant de parcourir les pièces jointes d'une sélection et affiche
' le nom et la taille de chaque pièce jointe dans une boîte de message
'---------------------------------------------------------------------------------------
'
'Déclarations des objets et variables
Dim
objItem As
Object
Dim
objAttachment As
Attachments
Dim
myOlApp As
New
Outlook.Application
Dim
myOlExp As
Outlook.Explorer
Dim
myOlSel As
Outlook.Selection
Dim
i As
Integer
'Instancie les objets
Set
myOlExp =
myOlApp.ActiveExplorer
Set
myOlSel =
myOlExp.Selection
'Boucle permettant de parcourir les pièces jointes une à une
For
Each
myItem In
myOlSel
'instancie l'objet avec la pièce jointe en cours
Set
objAttachment =
myItem.Attachments
'Si pièce jointe affichage
If
objAttachment.Count
>
0
Then
For
i =
1
To
objAttachment.Count
MsgBox
"Nom : "
&
objAttachment
(
i).FileName
&
vbCr
&
_
"Taille : "
&
MEF_Octet
(
objAttachment
(
i).Size
), , "Informations sur Pièces Jointes"
Next
i
End
If
Next
'Vide des objets pour libération de la mémoire
Set
objItem =
Nothing
Set
objAttachment =
Nothing
Set
myOlApp =
Nothing
Set
myOlExp =
Nothing
Set
myOlSel =
Nothing
End
Sub
La macro suivante appel une petite fonction permettant d'interpréter la valeur en octet et de la convertir en kilo, mega ou giga octets pour une meilleure lecture. La propriété Size renvoie la taille en octet des pièces jointes.
Public
Function
MEF_Octet
(
lgValeur As
Long
) As
String
'---------------------------------------------------------------------------------------
' Procédure : MEF_Octet
' Auteur : Dolphy35 - http://dolphy35.developpez.com/
' Date : 25/04/2008
' Détail : Fonction permettant un affichage en octet, kilo, mega ou giga selon valeur passée en paramètre
'---------------------------------------------------------------------------------------
'
'test si la valeur correspond à l'octet
If
(
lgValeur /
1024
>
1
) Then
lgValeur =
lgValeur /
1024
'test si la valeur correspond au kilo
If
(
lgValeur /
1024
>
1
) Then
lgValeur =
lgValeur /
1024
'test si la valeur correspond au méga
If
(
lgValeur /
1024
>
1
) Then
lgValeur =
lgValeur /
1024
'test si la valeur correspond au giga
If
(
lgValeur /
1024
>
1
) Then
lgValeur =
lgValeur /
1024
Else
MEF_Octet =
CStr
(
lgValeur) &
" Go"
'charge la valeur convertie en string dans la variable
End
If
Else
MEF_Octet =
CStr
(
lgValeur) &
" Mo"
'charge la valeur convertie en string dans la variable
End
If
Else
MEF_Octet =
CStr
(
lgValeur) &
" Ko"
'charge la valeur convertie en string dans la variable
End
If
Else
MEF_Octet =
CStr
(
lgValeur) &
" Oct"
'charge la valeur convertie en string dans la variable
End
If
End
Function
Attention cet événement n'est disponible que dans la version 2007 d'Outlook.
V-A-6. ItemSend▲
Cette procédure sera exécutée à chaque envoi d'éléments Outlook (Mail, réunion, tâche, etc.).
Cet événement dispose de deux paramètres obligatoires envoyés par l'élément en instance d'envoi :
1 - Item : correspond à l'élément envoyé. Ceci sous forme d'objet
2 - Cancel : paramètre de type Booléen, permet d'annuler l'envoi de l'objet en instance.
Exemple de code pouvant être mis dans cet événement :
Private
Sub
Application_ItemSend
(
ByVal
Item As
Object, Cancel As
Boolean
)
'---------------------------------------------------------------------------------------
' Procédure : Application_ItemSend
' Auteur : Dolphy35
' Site : http://dolphy35.developpez.com
' Détail : Demande une confirmation avant l'envoi d'un élément
'---------------------------------------------------------------------------------------
'Demande à l'utilisateur de valider si l'envoi doit être réaliser
If
MsgBox
(
"Voulez-vous réellement envoyer cet élément ???"
, _
vbQuestion
+
vbYesNo
, "Are You Sure !!"
) =
vbNo
Then
Cancel =
True
End
If
End
Sub
Le code précédent pose la question "Voulez-vous réellement envoyer cet élément ???",
si l'utilisateur répond Yes le mail sera envoyé, par contre s'il répond Non le mail
ne sera pas envoyé.
Autre exemple plus complet, celui-ci permet de tester si l'élément envoyé est
un Mail, si c'est le cas on test la présence d'un sujet et si celui-ci est vide
on affiche un message et on annule l'envoi.
Dans le cas où l'élément n'est pas un Mail nous sortons de la procédure par Exit Sub.
Pour tester si l'élément est un Mail nous utiliserons la propriété Class
qui renvoi une constante en fonction de l'élément. Pour un mail la constante est égale à
43 et son nom est olMail, pour retrouver la liste complète des Classes taper
OlObjectClass dans l'aide VBA (F1 depuis l'éditeur de code), suivez le lien
OlObjectClass, énumération.
Private
Sub
Application_ItemSend
(
ByVal
Item As
Object, Cancel As
Boolean
)
'---------------------------------------------------------------------------------------
' Procédure : Application_ItemSend
' Auteur : Dolphy35
' Site : http://dolphy35.developpez.com
' Détail : Permet de tester si présence d'un sujet avant l'envoi d'un Mail
'---------------------------------------------------------------------------------------
'
'Test si c'est un Email
If
Not
Item.Class
=
olMail Then
Exit
Sub
'Déclaration de la variable en tant que Mail
Dim
monMail As
MailItem
'Instancie L'élément à la variable Mail
Set
monMail =
Item
'Test si le sujet n'est pas vide
If
monMail.Subject
=
""
Then
'Message si sujet vide
MsgBox
"Veuillez saisir un Sujet à votre E-Mail"
'Annule l'envoi
Cancel =
True
End
If
End
Sub
V-A-7. ItemLoad▲
Cet événement sera exécuté lors de l'ouverture d'un élément, c'est à dire lors de
sa mise en mémoire. Seul l'objet est passé comme argument.
Le code
Private
Sub
Application_ItemLoad
(
ByVal
Item As
Object)
Select
Case
Item.Class
Case
olMail
MsgBox
"Vous ouvrez le Formulaire Mail"
Case
olContact
MsgBox
"Vous ouvrez le Formulaire Contact"
Case
olJournal
MsgBox
"Vous ouvrez le Formulaire Journal"
Case
olNote
MsgBox
"Vous ouvrez le Formulaire Notes"
End
Select
End
Sub
Disponible seulement depuis Outlook 2007.
V-A-8. MAPILogonComplete▲
Cet événement est exécuté après la connexion de l'utilisateur au process. L'exemple suivant est issu de l'aide Outlook - F1.
Private
Sub
Application_MAPILogonComplete
(
)
'Occurs when a user has logged on
MsgBox
"Logon complete."
End
Sub
V-A-9. NewMail▲
Cet événement est exécuté lors de la réception d'un nouveau message dans la boîte de réception. Aucun argument n'est utilisé pour cet événement. L'exemple suivant permet d'afficher un message lors de la réception d'un nouvel E-mail :
Private
Sub
Application_NewMail
(
)
MsgBox
"Vous venez de recevoir un nouveau Mail !"
, vbExclamation
End
Sub
Voici le résultat :
V-A-10. NewMailEx▲
Cet événement réagit de la même façon que le précédent à une chose près, il reçoit comme argument l'identificateur d'entrée de l'élément reçu, ceci permet de retrouver l'élément pour le manipuler. L'exemple suivant permet lors de l'arrivée d'un nouvel E-mail de tester l'adresse de l'expéditeur et si celui-ci correspond à notre occurrence nous déplaçons le message vers le dossier Temp :
Private
Sub
Application_NewMailEx
(
ByVal
EntryIDCollection As
String
)
'---------------------------------------------------------------------------------------
' Procédure : Application_NewMailEx
' Auteur : Dolphy35
' Site : http://dolphy35.developpez.com
' Détail : Permet de déplacer le nouveau message si celui-ci est envoyé par un expéditeur précis
'---------------------------------------------------------------------------------------
'
'Déclarations
Dim
MonApp As
Outlook.Application
Dim
MonMail As
Object
Dim
MonNameSpace As
Outlook.NameSpace
Dim
MonDossier As
Outlook.Folder
'Instance des objets
Set
MonApp =
Outlook.Application
Set
MonNameSpace =
MonApp.GetNamespace
(
"MAPI"
)
Set
MonDossier =
MonNameSpace.GetDefaultFolder
(
olFolderInbox)
Set
MonMail =
Application.Session.GetItemFromID
(
EntryIDCollection)
'Test si l'expéditeur correspond dans ce cas on déplace le mail
'vers le dossier Temp de votre boîte de réception
If
MonMail.SenderEmailAddress
=
"personne@domaine.fr"
Then
MonMail.Move
MonDossier.Folders
(
"Temp"
)
End
If
End
Sub
V-A-11. Quit▲
Cet événement survient lors de la fermeture d'Outlook.
L'exemple suivant permet d'afficher une boîte de message lors de
la fermeture d'Outlook :
Private
Sub
Application_Quit
(
)
MsgBox
"Au revoir, "
&
Application.GetNamespace
(
"MAPI"
).CurrentUser
End
Sub
V-A-12. Reminder▲
Cet événement survient avant l'affichage d'un rappel.
Private
Sub
Application_Reminder
(
ByVal
Item As
Object)
MsgBox
"Attention une alarme s'active"
, vbInformation
End
Sub
V-A-13. ShortcutContextMenuDisplay▲
Cet événement survient avant l'affichage du menu contextuel sur un Raccourci. L'exemple suivant permet de créer un contrôle dans le menu contextuel lors d'un clic droit sur un raccourci, exécute la macro définie et affiche dans une boîte de dialogue le nom du raccourci.
Dim
strSelection As
String
Private
Sub
Application_ShortcutContextMenuDisplay
(
_
ByVal
CommandBar As
Office.CommandBar
, _
ByVal
shctSelect As
OutlookBarShortcut)
Dim
objButton As
CommandBarButton
Dim
intButtonIndex As
Integer
Dim
intCounter As
Integer
Set
objButton =
CommandBar.Controls.Add
(
_
msoControlButton, , , , True
)
With
objButton
.Style
=
msoButtonIconAndCaption
.Caption
=
"Infos sur le Dossier"
.FaceId
=
463
.OnAction
=
"Projet 1.ThisOutlookSession.InfosDossier"
End
With
strSelection =
shctSelect.Name
End
Sub
Sub
InfosDossier
(
)
MsgBox
strSelection
End
Sub
Attention cet événement n'est disponible que dans la version 2007 d'Outlook.
V-A-14. Sartup▲
Cet événement est l'inverse du précédent, il survient lors de l'ouverture d'Outlook après avoir chargé tous les composants :
Private
Sub
Application_Startup
(
)
MsgBox
"Bonjour, "
&
Application.GetNamespace
(
"MAPI"
).CurrentUser
End
Sub
VI. Les Objets d'Outlook▲
Je vais dans ce paragraphe détailler les objets de modèles Outlook les plus utilisés.
Je vous invite à consulter en complément de cet article l'aide Outlook, depuis l'éditeur de code (VBE) frappez la touche F1, ensuite consultez les références du développeur Outlook.
VI-A. MailItem▲
L'objet MailItem correspond à un E-mail situé dans un dossier pouvant contenir des E-mails. En instanciant cet objet
à un E-mail vous pouvez par ses propriétés et méthodes récupérer des informations ou manipuler cet E-mail. La méthode
CreateItem permet, par exemple, de créer un nouvel E-mail. Vous pouvez également sélectionner un E-mail spécifique
par la méthode Items, celle-ci permet par l'index de la méthode de définir un message particulier par sa position dans
la collection d'objets, autre méthode chaque E-mail possède un ID c'est une chaîne de type String propre à chaque mail, cette
chaîne est unique par mail et permet de retrouver l'objet depuis la banque MAPI.
Passons aux exemples :
Premier exemple, création d'un Objet Mail
Pour se faire nous allons utiliser la méthode CreateItem, dans un premier temps il faut déclarer les objets :
Dim
MonApply As
Outlook.Application
Dim
MonMail As
Outlook.MailItem
Ensuite il nous faut instancier les Objets, nous utiliserons la constante olMailItem pour définir la création d'un nouvel E-mail :
'Instance des Objets
Set
myOlApp =
Outlook.Application
'Instance de l'application
Set
myItem =
myOlApp.CreateItem
(
olMailItem) 'Instance du nouvel E-mail
Simplement en changeant la constante olMailItem vous pouvez créer un autre objet avec le même code, en exemple :
Constante | Type d'objet |
---|---|
olAppointmentItem | Réunion |
olContactItem | Contact |
olDistributionListItem | Liste de distribution |
olJournalItem | Journal |
olMailItem | |
olNoteItem | Note |
olPostItem | Post-It |
olTaskItem | Tâche |
En dernier lieu l'affichage de l'Objet Mail par la méthode Display. Voici le code complet :
Sub
CreationMail
(
)
'---------------------------------------------------------------------------------------
' Procédure : CreationMail
' Auteur : Dolphy35 - http://dolphy35.developpez.com/
' Date : 06/05/2008
' Détail : Création d'un nouvel E-mail
'---------------------------------------------------------------------------------------
'
'Déclaration des objets
Dim
MonApply As
Outlook.Application
Dim
MonMail As
Outlook.MailItem
'Instance des Objets
Set
MonApply =
Outlook.Application
'Instance de l'application
Set
MonMail =
MonApply.CreateItem
(
olMailItem) 'Instance du nouvel E-mail
'Affichage du nouvel Objet Mail
MonMail.Display
'Vide des instances
Set
MonApply =
Nothing
Set
MonMail =
Nothing
End
Sub
Deuxième exemple, nous allons récupérer des infos sur l'E-mail sélectionné dans un dossier spécifique l'occurrence la boîte de réception
Pour cela nous utiliserons la méthode Items.
Dans un premier temps il nous faut déclarer les objets et variables :
'Déclaration des Objets et variables
Dim
MonApply As
Outlook.Application
Dim
MonMail As
Outlook.MailItem
Dim
MonNSpace As
Outlook.namespace
Dim
FldDossier As
Outlook.Folder
Dim
strInfos As
String
Ensuite il faut instancier les Objets, l'application Outlook, la NameSpace de la banque MAPI et en dernier lieu le dossier Boîte de réception :
'Instance des Objets
Set
MonApply =
Outlook.Application
'Application Outlook
Set
MonNSpace =
MonApply.GetNamespace
(
"MAPI"
) 'Banque MAPI
Set
FldDossier =
MonNSpace.GetDefaultFolder
(
olFolderInbox) 'Dossier boîte de réception
Il nous faut créer une boucle ayant pour limite le nombre de mails contenu dans le dossier, pour cela nous utiliserons
la méthode Count de la méthode Items du dossier. Ensuite nous réalisons un test sur le sujet et récupérons
des infos du mail lorsque le sujet correspond à l'occurrence du test. Nous affichons le résultat dans une MsgBox.
Voici le code complet :
Sub
InfoSelection
(
)
'---------------------------------------------------------------------------------------
' Procédure : InfoSelection
' Auteur : Dolphy35 - http://dolphy35.developpez.com/
' Date : 06/05/2008
' Détail : Information sur le message sélectionné de la boîte de réception
'---------------------------------------------------------------------------------------
'
'Déclaration des Objets et variables
Dim
MonApply As
Outlook.Application
Dim
MonMail As
Outlook.MailItem
Dim
MonNSpace As
Outlook.namespace
Dim
FldDossier As
Outlook.Folder
Dim
strInfos As
String
'Instance des Objets
Set
MonApply =
Outlook.Application
'Application Outlook
Set
MonNSpace =
MonApply.GetNamespace
(
"MAPI"
) 'Banque MAPI
Set
FldDossier =
MonNSpace.GetDefaultFolder
(
olFolderInbox) 'Dossier boîte de réception
'Initialisation de la chaîne de caractères
strInfos =
""
'Boucle afin de parcourir l'ensemble des E-mails présents dans le dossier Boîte de réception
For
i =
1
To
FldDossier.Items.Count
'instancie le mail suivant la valeur de la boucle
Set
MonMail =
FldDossier.Items
(
i)
'Test sur le sujet si égale à Invitation
If
MonMail.Subject
=
"Invitation"
Then
'Récupère les diverses informations du Mail ayant pour sujet Invitation
With
MonMail
strInfos =
"Expéditeur : "
&
.SenderEmailAddress
strInfos =
strInfos &
vbCr
&
"Destinataire(s) : "
&
.To
strInfos =
strInfos &
vbCr
&
"Date de réception : "
&
.ReceivedTime
End
With
'Affichage du résultat
MsgBox
strInfos
End
If
Next
i
'Vide des instances
Set
MonApply =
Nothing
Set
MonNSpace =
Nothing
Set
FldDossier =
Nothing
Set
MonMail =
Nothing
End
Sub
Vous trouverez toutes les méthodes, propriétés et événements depuis l'aide d'Outlook, pour les possesseurs de la suite 2007, l'aide de cette version a reçue une sérieuse amélioration, vous pouvez, je dirais même, vous devez en abuser.
VI-B. ContactItem▲
ContactItem correspond à l'objet Contact d'un dossier.Vous pouvez créer un nouveau Contact par la méthode
CreateItem. ContactItem permet également de manipuler les données d'un contact déjà présent.
Premier exemple, créer un nouveau contact :
Dans un premier temps vous devez déclarer les objets :
'Déclaration des objets
Dim
MonApply As
Outlook.Application
Dim
MonContact As
Outlook.ContactItem
Instance des objets :
'Instance des Objets
Set
MonApply =
Outlook.Application
'Instance de l'application
Set
MonContact =
MonApply.CreateItem
(
olContactItem) 'Instance du nouveau Contact
'Affichage du nouvel Objet Contact
Affichage de l'objet. Voici le code complet :
Sub
CreationContact
(
)
'---------------------------------------------------------------------------------------
' Procédure : CreationContact
' Auteur : Dolphy35 - http://dolphy35.developpez.com/
' Date : 06/05/2008
' Détail : Création d'un nouveau Contact
'---------------------------------------------------------------------------------------
'
'Déclaration des objets
Dim
MonApply As
Outlook.Application
Dim
MonContact As
Outlook.ContactItem
'Instance des Objets
Set
MonApply =
Outlook.Application
'Instance de l'application
Set
MonContact =
MonApply.CreateItem
(
olContactItem) 'Instance du nouveau Contact
'Affichage du nouvel Objet Contact
MonContact.Display
'Vide des instances
Set
MonApply =
Nothing
Set
MonContact =
Nothing
End
Sub
Deuxième exemple, nous allons créer un nouveau contact et remplir les champs principaux :
Pour cela nous ajouterons au code précédent ce bout de code qui permet de renseigner le nom, prénom, adresse mail et
nom de l'adresse mail.
'définit plusieurs attributs du nouveau contact
With
MonContact
.LastName
=
"Nom du contact"
.FirstName
=
"Prénom du contact"
.Email1Address
=
"mail@domaine.fr"
.Email1DisplayName
=
"Nom du mail"
End
With
Voici le code complet :
Sub
CreationContact
(
)
'---------------------------------------------------------------------------------------
' Procédure : CreationContact
' Auteur : Dolphy35 - http://dolphy35.developpez.com/
' Date : 06/05/2008
' Détail : Création d'un nouveau Contact
'---------------------------------------------------------------------------------------
'
'Déclaration des objets
Dim
MonApply As
Outlook.Application
Dim
MonContact As
Outlook.ContactItem
'Instance des Objets
Set
MonApply =
Outlook.Application
'Instance de l'application
Set
MonContact =
MonApply.CreateItem
(
olContactItem) 'Instance du nouveau Contact
'définit plusieurs attributs du nouveau contact
With
MonContact
.LastName
=
"Nom du contact"
.FirstName
=
"Prénom du contact"
.Email1Address
=
"mail@domaine.fr"
.Email1DisplayName
=
"Nom du mail"
End
With
'Affichage du nouvel Objet Contact
MonContact.Display
'Vide des instances
Set
MonApply =
Nothing
Set
MonContact =
Nothing
End
Sub
VI-C. AppointmentItem▲
AppointmentItem correspond à une entrée du Calendrier, cela peut être un Rendez-vous ou bien une Réunion
Dans l'exemple suivant nous allons créer et afficher un nouveau rendez-vous :
Sub
CreationRappel
(
)
'---------------------------------------------------------------------------------------
' Procédure : CreationRappel
' Auteur : Dolphy35 - http://dolphy35.developpez.com/
' Date : 07/05/2008
' Détail : Création d'une nouvelle entrée du calendrier
'---------------------------------------------------------------------------------------
'
'Déclaration des objets
Dim
MonApply As
Outlook.Application
Dim
MonCalendrier As
Outlook.AppointmentItem
'Instance des Objets
Set
MonApply =
Outlook.Application
'Instance de l'application
Set
MonCalendrier =
MonApply.CreateItem
(
olAppointmentItem) 'Instance de la nouvelle entrée du calendrier
'Affichage de l'entrée du calendrier
MonCalendrier.Display
'Vide des instances
Set
MonApply =
Nothing
Set
MonCalendrier =
Nothing
End
Sub
L'exemple suivant permet, à la différence du premier, de créer une réunion :
Sub
CreationReunion
(
)
'---------------------------------------------------------------------------------------
' Procédure : CreationReunion
' Auteur : Dolphy35 - http://dolphy35.developpez.com/
' Date : 16/05/2008
' Détail : Création d'une nouvelle entrée du calendrier
'---------------------------------------------------------------------------------------
'
'Déclaration des objets
Dim
objOutlook As
Outlook.Application
Dim
objReunion As
Outlook.AppointmentItem
'Instance des Objets
Set
objOutlook =
Outlook.Application
'Instance de l'application
Set
objReunion =
objOutlook.CreateItem
(
olAppointmentItem) 'Instance de la nouvelle entrée du calendrier
'définition de la réunion
With
objReunion
.MeetingStatus
=
olMeeting 'Programmation de la réunion "constante"
.Subject
=
"Sujet de la réunion"
'Sujet de la réunion
.Location
=
"Mon Bureau"
'Lieu de la réunion
.Recipients.Add
(
"adresse@fai.fr"
) 'Destinataire de la réunion
.Display
End
With
'Vide des instances
Set
objOutlook =
Nothing
Set
objReunion =
Nothing
End
Sub
VI-D. JournalItem▲
JournalItem correspond à une entrée du journal.
Dans l'exemple suivant nous allons créer une nouvelle entrée dans le module journal :
Sub
CreationJournal
(
)
'---------------------------------------------------------------------------------------
' Procédure : CreationJournal
' Auteur : Dolphy35 - http://dolphy35.developpez.com/
' Date : 06/05/2008
' Détail : Création d'une nouvelle entrée du journal
'---------------------------------------------------------------------------------------
'
'Déclaration des objets
Dim
MonApply As
Outlook.Application
Dim
MonJournal As
Outlook.JournalItem
'Instance des Objets
Set
MonApply =
Outlook.Application
'Instance de l'application
Set
MonJournal =
MonApply.CreateItem
(
olJournalItem) 'Instance de la nouvelle entrée du journal
'Affichage de l'entrée du journal
MonJournal.Display
'Vide des instances
Set
MonApply =
Nothing
Set
MonJournal =
Nothing
End
Sub
VI-E. NoteItem▲
NoteItem correspond à l'objet Note.
L'exemple suivant crée une nouvelle Note et l'affiche :
Sub
CreationNote
(
)
'---------------------------------------------------------------------------------------
' Procédure : CreationNote
' Auteur : Dolphy35 - http://dolphy35.developpez.com/
' Date : 06/05/2008
' Détail : Création d'une nouvelle Note
'---------------------------------------------------------------------------------------
'
'Déclaration des objets
Dim
MonApply As
Outlook.Application
Dim
MaNote As
Outlook.NoteItem
'Instance des Objets
Set
MonApply =
Outlook.Application
'Instance de l'application
Set
MaNote =
MonApply.CreateItem
(
olNoteItem) 'Instance de la nouvelle note
'Affichage de la nouvelle note
MaNote.Display
'Vide des instances
Set
MonApply =
Nothing
Set
MaNote =
Nothing
End
Sub
VI-F. PostItem▲
PostItem correspond à un Post-it.
L'exemple suivant permet de créer un nouveau Post-it :
Sub
CreationPostIt
(
)
'---------------------------------------------------------------------------------------
' Procédure : CreationPostIt
' Auteur : Dolphy35 - http://dolphy35.developpez.com/
' Date : 08/05/2008
' Détail : Création d'un nouveau Post-It
'---------------------------------------------------------------------------------------
'
'Déclaration des objets
Dim
MonApply As
Outlook.Application
Dim
MonPostIt As
Outlook.PostItem
'Instance des Objets
Set
MonApply =
Outlook.Application
'Instance de l'application
Set
MonPostIt =
MonApply.CreateItem
(
olPostItem) 'Instance du nouveau Post-It
'Affichage du nouveau Post-It
MonPostIt.Display
'Vide des instances
Set
MonApply =
Nothing
Set
MonPostIt =
Nothing
End
Sub
VI-G. TaskItem▲
TaskItem correspond à une tâche du dossier Tâches.
L'exemple suivant permet de créer une nouvelle tâche :
Sub
CreationTache
(
)
'---------------------------------------------------------------------------------------
' Procédure : CreationTache
' Auteur : Dolphy35 - http://dolphy35.developpez.com/
' Date : 08/05/2008
' Détail : Création d'une nouvelle Tâche
'---------------------------------------------------------------------------------------
'
'Déclaration des objets
Dim
MonApply As
Outlook.Application
Dim
MaTache As
Outlook.TaskItem
'Instance des Objets
Set
MonApply =
Outlook.Application
'Instance de l'application
Set
MaTache =
MonApply.CreateItem
(
olTaskItem) 'Instance de la nouvelle tâche
'Affichage de la nouvelle tâche
MaTache.Display
'Vide des instances
Set
MonApply =
Nothing
Set
MaTache =
Nothing
End
Sub
VII. Liens utiles▲
Le VBA est le langage générale d'office, seules quelques propriétés et collections changent, dans le principe vous pouvez consulter
les articles concernant le VBA de Word, Excel, Access, PowerPoint, Visio et Outlook.
Je vous invite à consulter les pages de cours des différentes rubriques :
- La page des Cours sur Word
- La page des Cours sur Excel
- La page des Cours sur Access
- La page des Cours sur PowerPoint
- La page des Cours sur Outlook
VIII. Remerciement▲
Merci à Heureux-oli,
Starec et
fring pour leur temps consacré à la lecture et correction.
Nono40 pour son excellent outil.
A www.developpez.com pour leur hébergement.