Introduction à Visual Basic for Application

Ce chapitre est un bref rappel de l’environnement VBA et de la syntaxe du langage. Pour davantage de précisions, se reporter au cours ENSG de la CPRI : « Visual Basic 6.0 »

EDITEUR VISUAL BASIC

La fenêtre de projet liste tous les modules de code de la carte courante, du Normal template ou bien d’un autre modèle sur lequel la carte est basée. Chaque module contient un certain nombre de « macros »( ou procédures) elles-mêmes constituées d’un certain nombre de lignes de code (instructions). Il existe trois type de modules :
– les modules standards
– les feuilles (ou « Userform »)
– les modules de classe (cf. chap. 1)
Une feuille est une boîte de dialogue créée par le développeur, contenant un certain nombre de « contrôles », par exemple des boutons, listbox, etc … A ces contrôles sont associés des événements associés à des procédures événementielles (par exemple, à l’événement clic sur un bouton, on va déclencher un certain traitement).
Il est préférable, pour une meilleure lisibilité du programme d’utiliser une convention de dénomination des contrôles,
Remarque : Lorsqu’on utilise l’éditeur VBA avec ArcMap, il existe un module « ThisDocument » gérant les événements liés au document (ouverture, fermeture etc … cf exemple § 5.5)

SYNTAXE VBA : RAPPELS

Types de variables

Il est préférable, pour une meilleure lisibilité du code, d’utiliser une convention faisant précéder chaque nom de variables d’un préfixe dépendant du type de variable,
La ligne « Option Explicit » en tête de module oblige le développeur à déclarer toutes les variables. En son absence, c’est le type de données « Variant » qui est attribué à toute variable non déclarée.

Déclaration et portée

Il existe trois niveaux de déclaration d’une variable :
– Niveau procédure :
La variable est uniquement valable à l’intérieur de la procédure. Elles est détruite quand la procédure est terminée. On utilise les mots-clé Private ou Dim pour déclarer la variable dans la procédure, par exemple :
Private Sub Exemple()
Dim i as integer
i = i + 1
MsgBox i
End Sub
Dim ré-initialise les variables (dans l’exemple ci-dessus, i = 0 après la déclaration). Pour conserver la valeur de la variable entre chaque éxecution de la procédure, il faut utiliser le mot-clé « Static ». Dans l’exemple suivant, la variable i est incrémentée à chaque exécution de la procédure :
Private Sub Exemple()
Static i as integer
i = i + 1
MsgBox i
End Sub
– Niveau module :
La variable est valable à l’intérieur du module tout entier. Elle est déclarée dans l’entête du module avec Dim ou Private puis on l’initialise dans la procédure, par exemple :
Dim strNom as string
Private Sub Exemple()
strNom = « Toto »
‘ traitements ….
End Sub
– Niveau Public :
La variable est valable dans tout le projet. On utilise par exemple ce type de variable lorsqu’on manipule plusieurs « forms ». Elle est déclarée avec le mot-clé « Public ». Si la variable est déclarée dans une « form », il faut faire référence à celle-ci lorsqu’on l’utilise ailleurs, par exemple :
form2.strNom = « Toto »
Dans les gros projets, il est fréquent de créer un module spécial pour la déclaration des variables « Public ».
Remarques :
• Attention à la façon de déclarer les variables :
Dim count as Long
Dim max as Long
est équivalent à
Dim count as Long, max as long ‘moins lisible
mais par contre, dans la ligne suivante, count est défini comme « variant » :
Dim count, max as Long
• Un tableau est une variable simple comportant de nombreux compartiments permettant de stocker autant de valeurs, par opposition à une variable classique dotée d’un compartiment destiné à une seule valeur. La déclaration d’un tableau se fait comme suit :
Dim curExpense(364) As Currency
qui s’utilise ensuite de la manière suivante :
Sub FillArray()
Dim curExpense(364) As Currency
Dim intI As Integer
For intI = 0 to 364
curExpense(intI) = 20
Next
End Sub
• Les constantes se déclarent comme suit (elles sont de type Private par défaut) :
Const MyVar = 459
ou bien :
Public Const MyPublicVar = 5784

Les différents types de procédures

– Procédures événementielles :
Elles sont associées à un objet (et sont exécutées quand l’événement correspondant se réalise. La syntaxe est la suivante : « object_event(parameters) ». Certains événements n’ont pas de paramètres (clic sur un bouton par exemple), alors que d’autres utilisent plusieurs paramètres (MouseMove par exemple) :
Private Sub CmdButton1_Click() ‘Clic sur le bouton CmdButton1
‘ …………
End Sub
Private Sub UIToolControl1_MouseMove(ByVal button As Long, _
ByVal shift As Long, ByVal x As Long, ByVal y As Long)
‘ Déplacement avec la souris de l’outil UIToolControl1 ‘……….
End Sub
– Procédures ou « SubRoutines » :
Une procédure est une série d’instructions exécutant des actions mais ne renvoyant pas de valeurs. Contrairement à une procédure événementielle, elle doit être appelée. La syntaxe est la suivante :
Portée
« Private »
ou « Public »
Mot-clé Paramètres. S’il n’y pas
Nom de la de paramètres, on ecrit
pour une
procédure procédure « Mymacro() »
Déclaration de la procédure
Private Sub MyMacro(strTexte as String)
MsgBox strTexte Instruction
End Sub Instruction de fin de
procédure
Call MyMacro(« Bonjour ») Appel de procédure
– Fonctions :
Une fonction est similaire à une procédure mais elle renvoie une valeur en affectant une valeur à son nom dans une ou plusieurs instructions de la procédure. La syntaxe est la suivante :
Type de données renvoyé par la fonction
Déclaration de la fonction
Private Function Divise_par_2(dblNum as Double) as Double
Divise_par_2 = dblNum / 2 La fonction renvoie cette valeur
End Function Instruction de fin de
fonction
Dim dblTest as double
dblTest = Divise_par_2(9) Appel de fonction
Si la valeur renvoyée par une fonction n’est pas utilisée, on peut appeler la fonction de la même manière qu’une procédure, sans affecter la fonction à une variable et en supprimant les parenthèses, par exemple :
MsgBox « Traitement terminé », vbExclamation, « Calcul des intersections … »
Attention, l’utilisation de parenthèses dans l’exemple précédent renvoie un message d’erreur :
MsgBox (« Traitement terminé », vbExclamation, « Calcul des intersections … »)
– Sorties de procédures :
Exit Sub permet de sortir d’une procédure
Exit Function permet de sortir d’une fonction

Instructions conditionnelles

– « If…Then…Else » :
L’instruction If…Then…Else permet d’exécuter une instruction spécifique ou un bloc d’instructions, selon la valeur d’une condition. La syntaxe est la suivante :
If condition Then
[statements]
[Else elsestatements]
Ou bien
If condition Then
[statements]
[ElseIf condition-n Then
[elseifstatements] …
[Else
[elsestatements]]
End If
Par exemple :
Sub AlertUser(value as Long)
If value = 0 Then
AlertLabel.ForeColor = vbRed
AlertLabel.Font.Bold = True
AlertLabel.Font.Italic = True
Else
AlertLabel.Forecolor = vbBlack
AlertLabel.Font.Bold = False
AlertLabel.Font.Italic = False
End If
End Sub
– « Select Case » :
L’instruction Select Case s’utilise en en remplacement de ElseIf dans des instructions If…Then…Else lors de la comparaison d’une expression à plusieurs valeurs différentes.
La syntaxe est la suivante :
Select Case testexpression
[Case expressionlist-n
[statements-n]] …
[Case Else
[elsestatements]]
End Select
Par exemple :
Function Bonus(performance, salary)
Select Case performance
Case 1
Bonus = salary * 0.1
Case 2, 3
Bonus = salary * 0.09
Case 4 To 6
Bonus = salary * 0.07
Case Is > 8
Bonus = 100
Case Else
Bonus = 0
End Select
End Function

Boucles

– « For..Next » :
Les instructions For…Next permettent de répéter un bloc d’instructions un certain nombre de fois. Les boucles For utilisent une variable de compteur dont la valeur est incrémentée ou décrémentée à chaque itération (suivant la valeur définie par le mot-clé step), par exemple :
Sub TwosTotal()
For j = 2 To 10 Step 2
total = total + j
Next j
MsgBox « Le total est de  » & total
End Sub
– « Do..Loop » :
Les instructions Do…Loop permettent d’exécuter un bloc d’instructions un nombre de fois indéfini, tant qu’une condition a la valeur True (avec while) ou jusqu’à ce qu’elle prenne la valeur True (avec until) :
Do [{While | Until} condition]
[statements]
Loop
– Sorties de boucles :
Exit Next permet de sortir d’une boucle For..Next
Exit Do permet de sortir d’une boucle Do..Loop

Passage d’arguments : ByRef et ByVal

Tous les arguments sont passés aux procédures par référence sauf indication contraire. Cette méthode est efficace en ce sens que le temps de passage des arguments et l’espace mémoire qu’ils occupent dans une procédure (4 octets) sont les mêmes quel que soit le type de données de l’argument.
Il est également possible de passer un argument par valeur en incluant le mot clé ByVal dans la déclaration de la procédure. Un argument passé par valeur occupe de 2 à 16 octets dans la procédure, en fonction de son type de données. Les types de données plus importants impliquent un temps de traitement supérieur à celui des types de données moins volumineux. Les types de données String et Variant ne doivent donc généralement pas être passés par valeur.
Lorsqu’un argument est passé par valeur, la variable d’origine est copiée dans la procédure. Les modifications apportées ensuite à l’argument au sein de la procédure ne sont pas répercutées sur la variable d’origine.

Quelques remarques supplémentaires

Il est possible d’écrire une instruction sur plusieurs lignes grâce au caractère  » _ » (espace suivi de blanc souligné) :
strNameList = « La carte contient  » & pMap.LayerCount _ & « couches : » & vbCrLf est équivalent à
strNameList = « La carte contient  » & pMap.LayerCount & « couches : » & vbCrLf
L’instruction With permet de spécifier un objet pour une série d’instructions. Les instructions With accélèrent l’exécution des procédures et permettent d’éviter des saisies répétitives.
Sub FormatRange()
With Worksheets(« Sheet1 »).Range(« A1:C10 »)
.Value = 30
.Font.Bold = True
.Interior.Color = RGB(255, 255, 0)
End With
End Sub

Introduction à ArcObjects

ArcObjects s’appuie sur la technologie COM ( Microsoft’s Component Object Model), il est donc possible d’étendre l’architecture d’ArcObjects en développant des composants utilisant la norme COM, de la même manière que peuvent le faire les développeurs d’ESRI. Attention, COM n’est pas un langage orienté objet mais une norme définissant des protocoles de connections entre différents composants logiciels, indépendament du langage de programmation. Il est ainsi possible de développer des composants logiciels réutilisables et échangeables. COM définit également un modèle de programmation dit « Interface-based programming ».
Les ArcObjects OMD (Object Model Diagrams) utilisent la modélisation UML avec quelques variantes afin de pouvoir représenter les spécificités de la norme COM (notament les interfaces). Ces modifications ajoutent des symboles pour représenter les différents types de propriétés et méthodes, représenter les relations d’instantiation et marquer la différence entre abstract classes, coclasses et classes (cf. § ci-dessous) . Ces diagrammes aident à comprendre l’architecture d’ArcObjects et complètent l’information accessibles via l’environnement de développement (liste des objets, méthodes et propriétés).

COM ET INTERFACES

Pourquoi des interfaces ?

Développer avec COM implique développer en utilisant des interfaces. Une interface est un groupe logique de méthodes et propriétés. Pour communiquer avec un objet, on passe par son interface.
Les interfaces permettent de faire évoluer une classe en ajoutant une nouvelle interface. Une interface ne peut jamais être supprimée mais l’implémentation peut être modifiée. Certains langages orienté-objet utilisent des classes et des objets mais pas d’interfaces, ce qui peut poser problème lorsqu’une classe a besoin d’être mise à jour. En effet, lorsqu’une classe et le code associé évoluent, les développements utilisant cette classe risquent de devenir obsolètes, voire ne plus fonctionner.
Les interfaces résolvent ce problème, puisque lorsqu’une classe a besoin d’être re-programmée, une nouvelle interface est créée.

1. INTRODUCTION
2. PERSONNALISATION DE L’INTERFACE : INTRODUCTION
2.1. LA BOITE PERSONNALISER
2.2. SAUVEGARDE DES PERSONNALISATIONS
2.3. EXEMPLE DE CREATION D’UNE COMMANDE
3. INTRODUCTION À VISUAL BASIC FOR APPLICATION
3.1. EDITEUR VISUAL BASIC
3.2. SYNTAXE VBA : RAPPELS
3.2.1. Types de variables
3.2.2. Déclaration et portée
3.2.3. Les différents types de procédures
3.2.4. Instructions conditionnelles
3.2.5. Boucles
3.2.6. Passage d’arguments : ByRef et ByVal
3.2.7. Quelques remarques supplémentaires
4. INTRODUCTION A ARCOBJECTS
4.1. COM ET INTERFACES
4.1.1. Pourquoi des interfaces ?
4.1.2. Implémentation
4.1.3. Query Interfaces (QI)
4.2. OBJECT MODEL DIAGRAMS
4.3. OU TROUVER DE L’AIDE ?
4.4. GLOBAL VARIABLES SCOPE
4.5. EXEMPLES : MANIPULATION D’OBJETS ARCMAP
5. LECTURE DE CHAMPS, REQUETE SEMANTIQUE, TRAVAIL SUR LA SELECTION
5.1. FEATURECLASS ET FEATURE
5.1.1. Présentation générale
5.1.2. IFeatureClass
5.1.3. Lecture de valeurs de champs
5.2. ENUMERATION DES OBJETS SELECTIONNES SUR LA CARTE
5.3. CURSEUR SUR LES OBJETS SELECTIONNES (SUR UNE COUCHE)
5.4. REQUETES SEMANTIQUE AVEC LES QUERY FILTERS
5.5. RECUPERATION D’EVENEMENT SUR LA SELECTION
6. GEOMETRIE
6.1. GEOMETRIE DANS UNE GEODATABASE
6.2. LA GEOMETRIE DANS ARCOBJECTS
6.3. EXEMPLE : LECTURE DE LA GEOMETRIE D’UN POLYGONE
7. AFFICHAGE ET RAFRAICHISSEMENT D’ECRAN
7.1. UTILISATION DU SCREENDISPLAY POUR DESSINER DES ELEMENTS GRAPHIQUES
7.2. RAFRAICHISSEMENTS D’ECRAN
8. SYMBOLES
8.1. COULEUR
8.2. POINTS
8.3. LIGNES
8.4. SURFACE
8.5. TEXTE
9. SYMBOLISATION DE COUCHES
9.1. LA CLASSE FEATURERENDERER
9.2. EXEMPLE : REPRESENTATION EN UTILISANT UNE CLASSIFICATION PAR INTERVALLES EGAUX
9.3. AFFICHAGE DE LABELS
10. MISE EN PAGE
10.1. SCHEMA GENERAL
10.2. CAS PARTICULIER DES ELEMENTS LIES A LA CARTE
10.3. GRAPHICS CONTAINER
10.4. EXEMPLE : AJOUT D’UNE IMAGE A LA MISE EN PAGE
10.5. ZOOM SUR LA PAGE
11. TRANSFORMATION DE COORDONNEES – PROJECTIONS
11.1. IDISPLAYTRANSFORMATION
11.2. CREATION D’UN OUTIL : EXEMPLE D’OUTIL « PAN »
11.3. REFERENCES SPATIALES ET PROJECTION
11.3.1. Références spatiales
11.3.2. Changement de projection
12. ANALYSE SPATIALE
12.1. SPATIALFILTER
12.2. SPATIAL OPERATOR INTERFACES
12.2.1. ITopologicalOperator
12.2.2. IProximityOperator
12.2.3. IRelationalOperator
12.3. TRANSFORMATIONS 2D
13. MISE A JOUR DE DONNEES
13.1. CREATION D’ENTITES OU AJOUT D’ENREGISTREMENTS DANS UNE TABLE
13.2. UTILISATION D’UNE SESSION D’EDITION
13.2.1. Introduction et rappel des fonctionnalités d’édition
13.2.2. Ouverture et fermeture d’une session d’édition
13.2.3. Opérations de mise à jour et annulations
14. AJOUT DE COUCHE A PARTIR DE DONNEES EXISTANTES
14.1. RAPPEL : LES DIFFERENTS MODES DE STOCKAGE DANS ARCCATALOG
14.2. SCHEMA GENERAL
14.3. EXEMPLE DETAILLE D’AJOUT DE DONNEES PROVENANT D’UN SHAPEFILE
14.4. EXEMPLE D’AJOUT DE DONNEES PROVENANT D’UNE COUVERTURE
15. CREATION D’UNE BASE DE DONNEES
15.1. CREATION D’UNE GEODATABASE
15.2. EXPORT ET CONVERSIONS
16. PROGRAMMATION DE L’INTERFACE UTILISATEUR
16.1. UTILISATION DES COMMANDES EXISTANTES
16.2. CREATION DE BARRES D’OUTILS, MENUS ET COMMANDES
16.2.1. Création d’une barre d’outil
16.2.2. Création de menus et commandes
16.2.3. Création d’un menu contextuel
16.3. BARRE DE PROGRESSION, BARRE D’ETAT
17. PERSONNALISATION ARCCATALOG
17.1. GXDIALOG
17.2. GXAPPLICATION ET GXSELECTION
17.3. GXVIEW
18. INDEX