Bonsoir,

Quand je clique sur un bouton, je voudrai qu'une image s'affiche. Comment pouvoir faire ce lien ?

Merci par avance,

Cécilia

Bonsoir Cecilia,

En programmant le bouton. Plus précisément par une procédure (VBA) qui affiche l'image attachée à l'évènement click du bouton.

Comme tu ne spécifie pas de conditions particulières, cela peut se faire aussi autrement, notamment en utilisant l'image elle-même. Un petit exemple (résultant d'un exercice antérieur que j'ai encore en stock) pour voir ce qu'on peut faire et préciser tes desiderata.

http://cjoint.com/?gcaP52RJqB

Bonjour Ferrand,

Non, c'est pas ce que je veux. D'ailleurs, quand je clique sur l'image, j'ai le message suivant : Impossible d'exécuter la macro etc.... j'ai dèjà cherché et ne sais pas quoi activer.

Je souhaitais mettre un bouton avec la boîte outils Controle Active X, puis dès que je clique sur celui-ci, je souhaite qu'une image s'affiche.

Bonne journée,

Cécilia

Si tu n'actives pas les macros aucune procédure VBA ne pourra s'exécuter

Bonsoir,

Merci pour ces réponses. Effectivement je n'avais pas activé les macros.
Oui, l'exemple peut me convenir mais comment faire cela.
Bonne soirée,
Cécilia

Bonsoir,

La façon dont tu formulais ta question initiale : cliquer sur un bouton pour afficher une image peut recouvrir des finalités extrêmement diverses dans des environnements tout aussi divers. Ces éléments vont bien évidemment conditionner tes choix définitifs...

Du point de vue des méthodes utilisables, qu'il s'agisse d'un bouton ou d'un autre type de contrôle la procédure à exécuter aura une série d'actions assez semblables à accomplir : identifier l'image et savoir où la trouver, la prélever ou la copier ou la déplacer, la mettre à l'emplacement prévu pour la montrer en la mettant s'il y a lieu dans la forme requise et prédéfinie.

S'agissant d'un classeur Excel, il convient de distinguer deux cas principaux selon que l'image est déjà dans le classeur ou non. Si l'image à prélever doit l'être sur un stock de 10000 images, il est bien évident qu'il n'est pas souhaitable de les précharger toutes dans le classeur, s'il n'y en a qu'une ou un petit nombre il sera généralement plus avantageux de les avoir à disposition dans le classeur. Mais quantité d'autres critères peuvent faire pencher vers l'une ou l'autre de ces situations. Si l'image est extérieure, il faudra prévoir que le code VBA puisse identifier son emplacement pour pouvoir l'insérer dans le classeur. On en fera l'économie si l'image est dans le classeur.

En général un clic sur le bouton (ou autre contrôle) affichera l'image et un clic sur l'image conduira à la désafficher. On aura donc deux procédures, une pour afficher, l'autre pour supprimer l'image.

Dans le cas que je t'ai présenté, où le bouton est remplacé par l'image elle-même réduite à une dimension de miniature, on fait l'économie du stockage des images à un autre endroit du classeur, on fait également l'économie de son identification (elle est identifiée par le clic), et comme c'est toujours sur l'image qu'on clique on peut utiliser la même procédure pour afficher ou réduire à nouveau l'image. Il n'y a donc qu'un seule macro qui fait les deux.

Du point de vue codage VBA, l'utilisation d'un bouton ou d'un autre contrôle ActiveX te fera programmer l'évènement click du contrôle, l'utilisation d'une autre forme (dont l'image) conduit à associer une macro à la forme. Au cas particulier présenté, cette association n'est pas effectuée préalablement mais réalisée à l'ouverture du classeur (évènement Open du classeur, qui assujettit la procédure d'affichage/réduction à un clic sur n'importe laquelle des formes [images] présentes). Ce qui permet d'ajouter ou substituer des images qui seront automatiquement concernée par la même procédure après ouverture du classeur.

Ces considérations pour te donner une idée plus précise de l'éventail des possiblités et méthodes de réalisation. Maintenant, la question du comment faire dépend de ton choix final. Tu peux examiner les deux macros présentes (Module1 et module classeur ThisWorkbook). La procédure principale définit un emplacement unique d'affichage, mémorise la position initiale pour la repositionner au même endroit lors de la réduction, applique un coefficient multiplicateur pour l'afficher (tous paramètres étant modifiables sans changer de méthode).

Regarde de plus près, définit précisément le résultat que tu veux obtenir à partir de quelle situation de départ, demande les explications dont tu as besoin...

Bonjour,
Tout d'abord encore merci pour cette réponse.
J'ai bien examiné les deux macros présentes (Module1 et module classeur ThisWorkbook).
Dans un premier temps celle-ci me convient très bien mais comment faire cela ?
"Height * 17" le 17 correspond à quoi car je pense que ce ne sont pas des pixels ?
Bonne soirée,
Cécilia

Dans le cas que je t'ai présenté, où le bouton est remplacé par l'image elle-même réduite à une dimension de miniature, on fait l'économie du stockage des images à un autre endroit du classeur, on fait également l'économie de son identification (elle est identifiée par le clic), et comme c'est toujours sur l'image qu'on clique on peut utiliser la même procédure pour afficher ou réduire à nouveau l'image. Il n'y a donc qu'un seule macro qui fait les deux.

17 n'est qu'un coefficient multiplicateur, tu peut prendre n'importe quel nombre, c'est fonction de la taille que tu veux obtenir pour l'image affichée.

La position de la miniature est définie par les coordonnées horizontale (Left) et verticale (Top) de l'angle supérieur gauche. Les valeurs sont mémorisées avant de l'agrandir. On agrandit l'image en hauteur (Height) et en largeur (Width) en multipliant ces dimensions par un coefficient (ici 17). On positionne l'image à partir de l'angle supérieur gauche de la fenêtre (Left=0 et Width=0, mais on peut la positionner où on veut). Lorsqu'on reclique sur l'image, la procédure identifie qu'elle mémorisé le nom de l'image, elle redivise les dimensions par le coefficient et la repositionne selon les coordonnées mémorisées.La mémorisation est faite simplement au moyen de variables statiques (qui conservent leur valeur entre deux appels de la procédure, déclarées avec le mot-clé Static), ce qui rend aisé l'utilisation de la même procédure pour les deux opérations.

Merci pour la rapidité, je commence à mieux comprendre. Mais je vais ou dans excel, je sais juste faire les simples en commençant par l'icône enregistrer une macro.
Cécilia

Inutile de chercher à enregistrer une macro, tu n'en obtiendras pas d'utilisable pour faire ce genre de chose. Tu vas dans l'éditeur Visual Basic, dans 2007 c'est sous l'onglet Développeur (il faut l'avoir activé dans les Options). Tu peux aussi faire Alt+F11 pour l'ouvrir.

Les macros sont des instructions (du code) tapées sous forme de texte dans des feuilles appelées Modules. Si tu fais un clic droit dans le volet gauche de l'éditeur (Projet, où est décrite la composition de ton classeur) et choisis Insertion dans le menu contextuel, tu auras le choix entre Userform, Module et Module de classe.

Les Userform sont des fenêtres affichables sous Windows, formulaires que tu peux utiliser dans ton application pour des choses très diverses. Laissons de côté pour le moment (ainsi que les modules de classe) et tu cliques sur Module. Tu verras un Module, simple feuille blanche pour y écrire du code dont tu pourras déclencher l'exécution (il sera alors lu par un interpréteur de commandes pour être exécuté).

Ces Modules, appelés aussi modules standard pour les distinguer des modules attachés à un objet (feuille de calcul, classeur, userform) sont ceux que tu utiliseras pour la plupart des macros courantes.

Ce que tu peux taper sur un Module se présente sous 3 formes : des instructions de déclarations (variables, constantes, définitions d'options), code non exécutable mais utilisé par le code exécutable, des procédures, soit le code exécutable, et des commentaires (pour t'y retrouver par la suite !). Tout ce que tu tapes sur une ligne à la suite d'une apostrophe (') (ou du mot-clé rem) n'est pas exécutable.

Tout le code exécutable ne peut être que dans les procédures. Les deux types principaux de procédures à utiliser sont les procédures Function (fonctions qui renvoient une valeur ou un résultat) et les procédures Sub (qui exécutent une action). Une telle procédure commence toujours par le mot-clé Sub suivi du nom que tu lui attribues et se termine par End Sub.

L'exécution d'une procédure peut être lancée manuellement (commande Macro du menu) ou attachée à une combinaison de touches, une commande de menu, un contrôle (bouton, etc.). Elle aussi être déclenchée automatiquement par un évènement prédéfini survenant dans Excel (modifier la sélection, activer la feuille, fermer le classeur, etc., il y a un grand nombre d'évènements utilisables). Ces procédures automatiques, qu'on appelle évènementielles, ne sont pas tapées dans les modules standars mais dans le module attaché à l'élément d'Excel qui subit l'évènement que l'on veut programmer, et elles ont des noms prédéfinis pour chaque évènement.

Par exemple, tu fais clic droit sur ThisWorkbook dans le même volet déjà vu et choisis Code, cela ouvrira le Module attaché au Classeur. C'est aussi une feuille blanche ! Tu déplies alors la liste déroulante de gauche ou apparaît (général) et tu sélectionnes Workbook. Tu vas voir apparaître sur le Module l'instruction:

Private Sub Workbook_Open(), suivi de End Sub 2 lignes plus bas

et il ne te reste plus qu'à taper entre ces 2 instructions le code que tu veux exécuter à l'ouverture du classeur (évènement par défaut du classeur). Si tu déroules la liste de droite tu pourras choisir d'autres évènements. Une procédure peut en appeler une autre. Supposons que tu utilises un classeur tous les jours et que tu y aies des choses différentes à faire selon que le jour est pair ou impair; tu as tapé une macro pour préparer le classeur pour les jours pairs et te l'afficher à la feuille utile (dans un module standard), tu en as tapé une seconde pour les jours impairs. Tu vas alors programmer l'ouverture du classeur pour qu'il évalue la date et selon qu'il s'agit d'un jour pair ou impair lance l'une ou l'autre des macros.

Tu peux aussi n'avoir tapé qu'une seule macro qui peut faire ce que font les 2 précédentes selon le jour: il faudra donc la lancer en lui disant si c'est pair ou impair; tu vas donc prévoir qu'elle soit appelée avec un argument (on les indique entre le parenthèses qui suivent le nom de la procédure) qui dans ce cas peut être de type booléen (vrai pour pair/faux pour impair). Ta procédure d'ouverture va alors toujours évaluer le jour mais pour définir la valeur de l'argument nécessaire pour lancer la macro unique.

Ouf si je continue je vais finir par me lancer dans un cours de VBA... On n'en est pas encore là, juste quelques rudiments pour que tu commences à te familiariser avec les éléments les plus utilisés et concevoir ce que tu veux faire de façon à pouvoir le programmer.

Tant que j'y suis voici une explication détaillée de la première macro (évènementielle):

Private Sub Workbook_Open()
Dim i%
'déclaration d'une variable i de type Integer (entier)
With Worksheets(1).Shapes
'instruction With... End With pour regrouper des éléments auxquels faire référence
'on fait référence à la collection Shapes (forme) de la feuille 1
'(les images font partie de la collection Shapes)
'la feuille est identifiée par son index: 1 désigne la 1re du classeur
'on peut remplacer 1 par un autre index ou par son nom (entre guillemets)
'veiller à ne pas mettre d'autres formes que les images sur la feuille utilisée
'cela provoquerait des erreurs
For i = 1 To .Count
.Item(i).OnAction = "AffichImage"
Next i
'les expressions débutant par un point se réfèrent à la collection définie avec With
'la propriété Count renvoie le nombre d'objets de la collection (images)
'Item se réfère à un élément de la collection suivi de son numéro d'index
'on peut omettre Item: les expressions Shapes(1) et Shapes.Item(1) sont équivalentes
'son utilisation ici est motivée par la mise en référence commune de Shapes (avec With)
'on utilise une boucle (For... Next) utilisant la variable i comme compteur
'la boucle va se répéter de 1 au nombre d'images (Count)
'à chaque tour de boucle i représentera le numéro d'index d'une image différente
'OnAction permet d'affecter une macro à l'objet image (qui sera lancée par un clic sur l'objet)
'l'affectation se fait au moyen du signe = suivi du nom de la macro entre guillemets
'en fin de boucle la macro aura été affectée à toutes les images
End With
End Sub

Bonsoir,
Merci pour toutes ses informations.
Ca me parait assez compliqué mais je vais essayer.
Cécilia

Bonsoir,

Je me rends compte que je ne t'avais pas mis la macro principale avec explications:

Sub AffichImage()
Static aff As Boolean, c(1) As Single, nima As String
'déclaration de variables statiques qui conserveront la valeur acquise en fin de procédure
'pour l'appel suivant de la procédure jusqu'à ce qu'on modifie cette valeur
'aff, variable de type booléen servira à indiquer si une image est affichée
'vrai (True) si affichée, faux (False) dans le cas contraire
'au premier appel, la valeur de aff est False (par défaut)
'c(1) déclare une variable tableau de type Single (décimal en simple précision)
'un tableau à 2 éléments: 0 et 1 (0 étant le premier élément par défaut, on ne l'indique pas)
'(une instruction: Option Base 1 en tête de module permettrait de changer le 1er numéro par défaut)
'(on peut aussi forcer la numérotation des éléments: par ex. 2 To 6)
'ce tableau sera utilisé pour mémoriser les coordonnées de l'image manipulée
'nima est une variable de type String (chaîne, texte)
'elle sera utilisée pour mémoriser le nom de l'image
Dim ima As Shape
'déclaration d'une variable ordinaire (sa valeur n'est pas conservée en fin de procédure)
'ima est une variable objet, le type d'objet pouvant lui être affecté est défini (Shape)
Set ima = ActiveSheet.Shapes(Application.Caller)
'l'instruction Set sert à affecter un objet à une variable objet
'on affecte à ima une forme de la feuille active identifiée par l'expression Application.Caller
'cette expression indique quel élément a déclenché l'exécution du code
'et dans ce cas particulier en renvoyant le nom de la forme sur laquelle on a cliqué
'l'image cliquée est donc affectée à la variable ima
'dès lors toute manipulation de la variable affectera directement l'objet image concerné
With ima
'référence à l'image cliquée pour les instructions entre With et End With
If aff Then
'condition pour exécuter le code qui suit: que aff ait la valeur vrai
'au premier appel de la macro, cette condition n'est pas réunie (valeur faux par défaut)
'il s'agit du code exécuté lorsqu'une image est affichée et qu'on clique pour la réduire
If ima.Name <> nima Then Exit Sub
'on vérifie que le nom de l'image sur laquelle on a cliqué est celui mémorisé lors de son affichage
'précaution supplémentaire pour le cas de fausse manoeuvre ou d'incident
'dans ce cas la procédure est abandonnée (Exit Sub)
'si on a bien une image à réduire la procédure se poursuit
.Height = .Height / 17
.Top = c(0)
.Left = c(1)
'la hauteur est divisée par le coefficient qui a servi à son agrandissement
'cette opération affecte la largeur dans la même proportion
'la conservation de la proportionalité est définie dans les propriétés de l'image
'les cordonnées verticale et horizontale sont rétablies à leur valeur mémorisée
'l'image affichée se retrouve donc à sa position initiale
Else
'Else (sinon) précède les instructions à exécuter si la condition n'est pas vraie
'soit s'il n'y a pas d'image à réduire et donc qu'on a cliqué pour en afficher une
c(0) = .Top
c(1) = .Left
'on affecte chacune des coordonnées de l'image miniature à un élément du tableau c (pour les conserver)
nima = ima.Name
'on affecte son nom à la variable nima (également pour mémoriser)
.Top = 0
.Left = 0
'on définit de nouvelles coordonnées de l'image (Top et Left) à 0 pour occuper toute la fenêtre
.Height = .Height * 17
'on affecte un coefficient multiplicateur à la hauteur (l'image grossit en proportion)
.ZOrder msoBringToFront
'on la positionne au premier plan (elle recouvre donc en principe les miniatures qu'on clique)
'(étant la seule visible, on ne peut normalement que cliquer sur elle ensuite pour la réduire)
End If
End With
aff = Not aff
'on inverse la valeur de aff (devient vrai si était faux et vice versa)
'(au 1er appel la valeur était faux, on a affiché une image, elle sera vrai à l'appel suivant)
End Sub
'NB: pour bien faire il faudrait veiller à ce qu'il n'y ait pas une image affichée à l'ouverture,
'donc à ne pas qu'il soit enregistré avec une image affichée, ce qui est possible en programmant
'les évènements enregistrement (BeforeSave) et/ou fermeture (BeforeClose) du classeur de façon
'à vérifier qu'une image ne soit pas affichée et à la réduire le cas échéant avant enregistrement.