Logo GNT
Actualités Tests & Guides Bons Plans
GTA 6 iPhone 17 Copilot Switch 2 Temu ChatGPT Tesla
OVH Cloud OVH Cloud
Entraide Développement Développement Visual Basic Annuler et Refaire plusieurs fois...

Annuler et Refaire plusieurs fois...

17 réponses
Avatar
Armando R.
Bonjour,
Dans mon application, j'utilise la commande CLS pour effacer la dernière
opération effectuée sur un PictureBox.
je voudrais pouvoir annuler plusieurs opérations l'une après l'autre et
aussi revenir en arrière. quelqu'un aurait il un petit exemple que je puisse
adapter à mon application ?
merci d'avance...
Signaler un problème avec ce contenu

10 réponses

Supprimer
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire

Veuillez sélectionner un problème

Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
1 2
Avatar
ng
Salut,

Que fais tu sur ta picturebox come opération ?

La solution serait de stocker dans un tableau l'image avant de faire une
opération.
Le problème c'est que si tu as de grosses images ca risque d'etre assez
gourmand en mémoire.

--
Nicolas G.
FAQ VB : http://faq.vb.free.fr
API Guide : http://www.allapi.net
Google Groups : http://groups.google.fr/
MZ-Tools : http://www.mztools.com/

Armando R. wrote:
Bonjour,
Dans mon application, j'utilise la commande CLS pour effacer la
dernière opération effectuée sur un PictureBox.
je voudrais pouvoir annuler plusieurs opérations l'une après l'autre
et aussi revenir en arrière. quelqu'un aurait il un petit exemple que
je puisse adapter à mon application ?
merci d'avance...


Avatar
ng
Salut,

On est pas en C++ :)
Les pointeurs et l'héritages c'est pas trop le truc de VB :)

--
Nicolas G.
FAQ VB : http://faq.vb.free.fr
API Guide : http://www.allapi.net
Google Groups : http://groups.google.fr/
MZ-Tools : http://www.mztools.com/

dark poulpo wrote:
Bonjour,
Dans mon application, j'utilise la commande CLS pour effacer la
dernière opération effectuée sur un PictureBox.
je voudrais pouvoir annuler plusieurs opérations l'une après l'autre
et aussi revenir en arrière. quelqu'un aurait il un petit exemple
que je puisse adapter à mon application ?
merci d'avance...



une sorte d'undo et redo quoi!!!!!!
pour une image, alors tu va devoir te creer une sorte de pile
contenant le contenu de ta picturebox.

mais a ta place je ferai une classe CDo, et des classes heritées de
CDo (CDo_picturebox, CDo_autre action,.....)
avec les fonctions suivantes:
replique() // qui va refaire cette action (chaque classe a son propre
code adapté a l'interieur)
applique()// qui va mettre le contenu sauvé
...
(il est possible que tu adapate ce code en mettant par exemple un
paramettre indiquant l'objet) par exemple si ta 2 picturebox, pas la
peine de coder 2 classes CDo_picturebox_1 et CDo_picturebox_2)

toi tu fais une pile de pointeur vers la classe CDo. et dans ta pile
tu push ou tu pop tes classes CDo_picturebox, CDo_autre action,... en
fonction de l'action

ainsi tu pourra gerer d'autre chose en undo redo que le contenu de ta
picturebox.


Avatar
dark poulpo
> Bonjour,
Dans mon application, j'utilise la commande CLS pour effacer la dernière
opération effectuée sur un PictureBox.
je voudrais pouvoir annuler plusieurs opérations l'une après l'autre et
aussi revenir en arrière. quelqu'un aurait il un petit exemple que je


puisse
adapter à mon application ?
merci d'avance...



une sorte d'undo et redo quoi!!!!!!
pour une image, alors tu va devoir te creer une sorte de pile contenant le
contenu de ta picturebox.

mais a ta place je ferai une classe CDo, et des classes heritées de CDo
(CDo_picturebox, CDo_autre action,.....)
avec les fonctions suivantes:
replique() // qui va refaire cette action (chaque classe a son propre code
adapté a l'interieur)
applique()// qui va mettre le contenu sauvé
...
(il est possible que tu adapate ce code en mettant par exemple un paramettre
indiquant l'objet) par exemple si ta 2 picturebox, pas la peine de coder 2
classes CDo_picturebox_1 et CDo_picturebox_2)

toi tu fais une pile de pointeur vers la classe CDo. et dans ta pile tu push
ou tu pop tes classes CDo_picturebox, CDo_autre action,... en fonction de
l'action

ainsi tu pourra gerer d'autre chose en undo redo que le contenu de ta
picturebox.

--
-----
http://dark.freezee.org/
- Dark Update v1.0
- Dark Emule v0.44b r4
- Dark 3D-X (le desktop 3d pour windows) (----------> v0.7 beta dispo)
Avatar
dark poulpo
> On est pas en C++ :)
Les pointeurs


byref

et l'héritages c'est pas trop le truc de VB :)


pour lheritage jetais pas sur :-p , mais il peut contourner en sockant dans
un variant les classes CDo_.....
Avatar
Armando R.
En fait mon image équivaut a une feuille A4 !!!
j'essaye de stocker les images dans 3 PictureBox en les décalant a chaque
opération, une sorte de (registre à décalage) mais ça marche pas bien j'ai
du mal a synchroniser tout ça.


"ng" a écrit dans le message de news:
%
Salut,

Que fais tu sur ta picturebox come opération ?

La solution serait de stocker dans un tableau l'image avant de faire une
opération.
Le problème c'est que si tu as de grosses images ca risque d'etre assez
gourmand en mémoire.

--
Nicolas G.
FAQ VB : http://faq.vb.free.fr
API Guide : http://www.allapi.net
Google Groups : http://groups.google.fr/
MZ-Tools : http://www.mztools.com/

Armando R. wrote:
Bonjour,
Dans mon application, j'utilise la commande CLS pour effacer la
dernière opération effectuée sur un PictureBox.
je voudrais pouvoir annuler plusieurs opérations l'une après l'autre
et aussi revenir en arrière. quelqu'un aurait il un petit exemple que
je puisse adapter à mon application ?
merci d'avance...






Avatar
Patrick Philippot
Armando R. wrote:
je voudrais pouvoir annuler plusieurs opérations l'une après l'autre



Bonjour,

La mise en place d'un mécanisme d'undo/redo nécessite de répondre à 2
questions: comment et quoi?

Comment?
-------------

En général, un tel mécanisme va être mis en oeuvre par le biais d'une
double pile. Au fur et à mesure de leur exécution, les actions de
l'utilisateur sont empilées sur la pile Undo. Si une commande Undo est
déclenchée, la dernière action exécutée est dépilée, son effet est
annulé (voir plus bas) et l'action est réempilée sur la pile Redo afin
de satisfaire une éventuelle commande Redo.

Les piles en questions peuvent être soit limitées en taille (nombre
limité de undo/redo), soit être ajustées dynamiquement. En VB, il me
paraît assez simple d'implémenter une classe Pile à partir d'un objet
Collection.

Une alternative à la méthode des piles est la méthode de la sauvegarde
incrémentale utilisée par exemple par Word en connexion avec les
storages (voir interface COM IStorage pour les explication sur les
storages - fichiers composites ou compound documents). Tous les
documents Office sont en fait des storages (système de fichier à
l'intérieur d'un fichier). Word utilise pour son système d'Undo/Redo la
possibilité que donne le storage de travailler en mode incrémental (on
ne stocke que ce qui change dans des répertoires séparés) associée à la
capacité des storages de travailler en mode transactionnel (commit /
rollback). Cette approche est très intéressante mais beaucoup plus
complexe et nécessite une bonne connaissance du COM et de la
manipulation des storages.

Quoi?
-------

La question qui vient immédiatement derrière est "que va-t-on mettre sur
ces piles?". Il est évident que stocker l'état complet du document pour
chaque action, surtout dans le cas des images, amène rapidement soit à
une saturation de la mémoire, soit à une forte limitation du nombre
d'actions undo autorisées. Cela peut cependant faire l'affaire dans
certains cas.

L'approche la plus efficace est cependant de stocker un ensemble de
données décrivant la commande qui vient d'être réalisée. A chaque
commande mise à la disposition de l'utilisateur doit correspondre un
objet "commande inverse" qui décrit l'action à entreprendre pour annuler
éventuellement l'effet de la commande qui va être exécutée. C'est cette
description que l'on stocke sur la pile Undo. A contrario, on stockera
sur la pile Redo l'inverse de la "commande inverse" que l'on vient de
dépiler de la pile Undo.

Il est clair que la mise en oeuvre de cette approche nécessite une
réflexion préalable sur la manière dont les commandes utilisateurs sont
traitées et décrites dans le programme. Ce qui veut dire que chaque
commande (et commande inverse) doit être décrite par un objet qui
contient toutes les informations nécessaires à l'exécution de l'action
ou à la création d'une commande inverse annulant l'effet de cette
action. Ce n'est pas un travail très simple en VB dont les capacités
objet sont très limitées.

Pour les images, une autre approche consisterait à ne stocker que le
"delta" entre les images (avant et après l'action utilisateur). ce delta
peut se calculer en comparant les 2 images par quelques opérations
binaires simples. L'inconvénient, c'est que le résultat peut être de
taille très petite ou de la même taille que l'image complète selon
l'action qui aura été exécutée. en cela, cette approche est
intermédiaire entre la méthode décrite ci-dessus (commandes inverses) et
l'approche "stockage de chaque version du document".

--
Patrick Philippot - Microsoft MVP
MainSoft Consulting Services
www.mainsoft.fr
Avatar
ng
byref equivaut plutot à un passage par référence :

Public Sub MaFonction(ByRef a As Integer)
void MaFonction(int& a)

je définirai plus un poiteur comme une adresse, en C++ int* a passerait
carrement l'adresse que l'on peut afficher sans traitement par a alors qu'en
VB...
les seules notions de pointeurs en vb seraient StrPtr() & co, AddressOf
(pointeur vers une fonction), et les Object (qui stocke juste une adresse
sur un long)

toi tu parlais d'une pile de pointeur, ca serait assez restrictif, il faudré
que tes objets pointées puissent etre des Object VB (classe, classe COM,
controles vb).

cela dit on pourrait très bien faire une pile de StdPicture mais comme je le
disais ca risque d'etre gros (surtout pour du A4).

une solution plus élégante serait de travailler en vectoriel.

--
Nicolas G.
FAQ VB : http://faq.vb.free.fr
API Guide : http://www.allapi.net
Google Groups : http://groups.google.fr/
MZ-Tools : http://www.mztools.com/

dark poulpo wrote:
On est pas en C++ :)
Les pointeurs


byref

et l'héritages c'est pas trop le truc de VB :)


pour lheritage jetais pas sur :-p , mais il peut contourner en
sockant dans un variant les classes CDo_.....


Avatar
ng
ah oui j'oubliais, les seules notions d' "héritage" que VB connait
permettent de faire du polymorphisme primaire via le mot clef Implements
(implémentation d'interface).

--
Nicolas G.
FAQ VB : http://faq.vb.free.fr
API Guide : http://www.allapi.net
Google Groups : http://groups.google.fr/
MZ-Tools : http://www.mztools.com/

dark poulpo wrote:
On est pas en C++ :)
Les pointeurs


byref

et l'héritages c'est pas trop le truc de VB :)


pour lheritage jetais pas sur :-p , mais il peut contourner en
sockant dans un variant les classes CDo_.....


Avatar
ng
Salut,

Pour ce qui est du calcul de la modification entre 2 actions (ce que tu
appelles delta), cela me parait être une très bonne solution bien qu'assez
groumande en CPU en VB je pense.
Et le stockage ne serait pas si évident, il faudrait détecter toutes les
regions modifiées et les mettre dans un tableau de structures définie comme
suit (enfin c'est ce que je ferai, il y a peut être une meilleure approche)
:

Public Type Region
tCoord As Point 'structure contenant X, Y, la position del a région
tRegion As Region 'qui pourrait être un StdPicture ou tt autre objet
pour stocker une image
End Type

Il suffirait ensuite de recoller les morceau sur l'image pour revenir en
arrière.

--
Nicolas G.
FAQ VB : http://faq.vb.free.fr
API Guide : http://www.allapi.net
Google Groups : http://groups.google.fr/
MZ-Tools : http://www.mztools.com/

Patrick Philippot wrote:
Armando R. wrote:
je voudrais pouvoir annuler plusieurs opérations l'une après l'autre



Bonjour,

La mise en place d'un mécanisme d'undo/redo nécessite de répondre à 2
questions: comment et quoi?

Comment?
-------------

En général, un tel mécanisme va être mis en oeuvre par le biais d'une
double pile. Au fur et à mesure de leur exécution, les actions de
l'utilisateur sont empilées sur la pile Undo. Si une commande Undo est
déclenchée, la dernière action exécutée est dépilée, son effet est
annulé (voir plus bas) et l'action est réempilée sur la pile Redo afin
de satisfaire une éventuelle commande Redo.

Les piles en questions peuvent être soit limitées en taille (nombre
limité de undo/redo), soit être ajustées dynamiquement. En VB, il me
paraît assez simple d'implémenter une classe Pile à partir d'un objet
Collection.

Une alternative à la méthode des piles est la méthode de la sauvegarde
incrémentale utilisée par exemple par Word en connexion avec les
storages (voir interface COM IStorage pour les explication sur les
storages - fichiers composites ou compound documents). Tous les
documents Office sont en fait des storages (système de fichier à
l'intérieur d'un fichier). Word utilise pour son système d'Undo/Redo
la possibilité que donne le storage de travailler en mode incrémental
(on ne stocke que ce qui change dans des répertoires séparés)
associée à la capacité des storages de travailler en mode
transactionnel (commit / rollback). Cette approche est très
intéressante mais beaucoup plus complexe et nécessite une bonne
connaissance du COM et de la manipulation des storages.

Quoi?
-------

La question qui vient immédiatement derrière est "que va-t-on mettre
sur ces piles?". Il est évident que stocker l'état complet du
document pour chaque action, surtout dans le cas des images, amène
rapidement soit à une saturation de la mémoire, soit à une forte
limitation du nombre d'actions undo autorisées. Cela peut cependant
faire l'affaire dans certains cas.

L'approche la plus efficace est cependant de stocker un ensemble de
données décrivant la commande qui vient d'être réalisée. A chaque
commande mise à la disposition de l'utilisateur doit correspondre un
objet "commande inverse" qui décrit l'action à entreprendre pour
annuler éventuellement l'effet de la commande qui va être exécutée.
C'est cette description que l'on stocke sur la pile Undo. A
contrario, on stockera sur la pile Redo l'inverse de la "commande
inverse" que l'on vient de dépiler de la pile Undo.

Il est clair que la mise en oeuvre de cette approche nécessite une
réflexion préalable sur la manière dont les commandes utilisateurs
sont traitées et décrites dans le programme. Ce qui veut dire que
chaque commande (et commande inverse) doit être décrite par un objet
qui contient toutes les informations nécessaires à l'exécution de
l'action ou à la création d'une commande inverse annulant l'effet de
cette action. Ce n'est pas un travail très simple en VB dont les
capacités objet sont très limitées.

Pour les images, une autre approche consisterait à ne stocker que le
"delta" entre les images (avant et après l'action utilisateur). ce
delta peut se calculer en comparant les 2 images par quelques
opérations binaires simples. L'inconvénient, c'est que le résultat
peut être de taille très petite ou de la même taille que l'image
complète selon l'action qui aura été exécutée. en cela, cette
approche est intermédiaire entre la méthode décrite ci-dessus
(commandes inverses) et l'approche "stockage de chaque version du
document".


Avatar
Armando R.
bon... je crois que c'est pas gagné pour moi !... :((

"Armando R." a écrit dans le message de news:
41fb6398$0$27938$
Bonjour,
Dans mon application, j'utilise la commande CLS pour effacer la dernière
opération effectuée sur un PictureBox.
je voudrais pouvoir annuler plusieurs opérations l'une après l'autre et
aussi revenir en arrière. quelqu'un aurait il un petit exemple que je
puisse adapter à mon application ?
merci d'avance...




1 2