Discussion :

[luiso]

CBuilderXE

Bonjour,

Ayant besoin de Undo/Redo avec Manager, et ne trouvant rien en C++builder d'exploitable,
j'ai fini par trouvé un "composant invisible" si on peut dire?: UNDOREDO fait avec "_State.pas" et "UndoRedoState.pas" et avec un exemple delphi.
Il fonctionne parfaitement en delphi mais dont j'ai problème en C++BuilderXE depuis cette semaine.

L'Erreur:
Le projet Projet2.exe a déclenché la classe d'exception EAccessViolation avec le message 'Violation d'accès à l'adresse 00401CC7 dans le module 'Projet2.exe'. Lecture de l'adresse 00000000'.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
//mon code h:
 
#include "UndoRedoState.hpp" //créé par les composants
#include "_State.hpp"        //créé par les composants
//---------------------------------------------------------------------------
class TForm2: public TForm, IState
{
  typedef TForm inherited;
__published:
  TImage *ImageVue;
  TSpeedButton *Redo1;
  TSpeedButton *Undo1;
  void __fastcall FormCreate(TObject * Sender);
  void __fastcall FormDestroy(TObject * Sender);
  void __fastcall ImageVueMouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y);
  void __fastcall ImageVueMouseMove(TObject *Sender, TShiftState Shift, int X, int Y);
  void __fastcall ImageVueMouseUp(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y);
  void __fastcall Undo1Click(TObject *Sender);
  void __fastcall Redo1Click(TObject *Sender);
 
private:
  TUndoRedoState *FUndoRedo;
  bool FMouseDown;
public:
	__fastcall TForm2(TComponent* Owner);
  void __fastcall GetState(TStream *S);
  void __fastcall SetState(TStream *S);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm2 * Form2;
//---------------------------------------------------------------------------
#endif
 
//Code cpp
 
//#pragma link "_State"         // n'apporte rien de plus
//#pragma link "UndoRedoState"  // n'apporte rien de plus
 
//-------------------------------------------------
void __fastcall TForm2::GetState(TStream *S)
{ // mem écrit
  ImageVue->Picture->Bitmap->SaveToStream(S);
}
//---------------------------------------------------------------------------
void __fastcall TForm2::SetState(TStream *S)
{ //mem lit
  ImageVue->Picture->Bitmap->LoadFromStream(S);
}
//---------------------------------------------------------------------------
void __fastcall TForm2::FormCreate(TObject * Sender)
{ // Prépare l'image
 ImageVue->Picture->Bitmap->Width  = ImageVue->Width;
 ImageVue->Picture->Bitmap->Height = ImageVue->Height;
 TUndoRedoState *FUndoRedo;
}
//---------------------------------------------------------------------------
void __fastcall TForm2::Redo1Click(TObject *Sender)
{ // Redo
   FUndoRedo->Undo();
}
//---------------------------------------------------------------------------
void __fastcall TForm2::Undo1Click(TObject *Sender)
{  // Undo
  FUndoRedo->Redo();
}
//---------------------------------------------------------------------------
void __fastcall TForm2::ImageVueMouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y)
{ // Dessine à main nue (fait pour l'essai undo redo)
  if(FMouseDown)  return;
  FMouseDown = true;   FUndoRedo->BeginModify();   ImageVue->Canvas->MoveTo(X, Y);
}
//---------------------------------------------------------------------------
void __fastcall TForm2::ImageVueMouseMove(TObject *Sender, TShiftState Shift, int X, int Y)
{   // Dessine à main nue
  if(FMouseDown) ImageVue->Canvas->LineTo(X, Y);
 }
//---------------------------------------------------------------------------
void __fastcall TForm2::ImageVueMouseUp(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y)
{   // Finished Editing
  if(FMouseDown) {  FUndoRedo->EndModify();  FMouseDown = false;   }
}
//---------------------------------------------------------------------------
void __fastcall TForm2::FormDestroy(TObject * Sender)
{ // Libère
  FUndoRedo->Free();
}

Si quelqu'un pouvait me dire ou se trouve mon erreur?
Je peux fournir le dossier de cette application au besoins...
D'avance merci.
luiso

[getz85]

Déjà, dans la création de ta form, tu déclare un deuxième TUndoRedoState avec le même nom que celui contenu dans ton fichier d'entête, donc déclaration à virer (celui contenu dans le FormCreate bien sur).

Ensuite, pour utiliser un pointeur, il faut lui allouer de la mémoire, chose que tu n'as pas faite, d'où la violation d'accès. Ton OnCreate deviendra donc:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
void __fastcall TForm2::FormCreate(TObject * Sender)
{ // Prépare l'image
 ImageVue->Picture->Bitmap->Width  = ImageVue->Width;
 ImageVue->Picture->Bitmap->Height = ImageVue->Height;
 FUndoRedo = new TUndoRedoState(); 
 // ou si le constructeur a besoin d'un 'Owner' : 
 // FUndoRedo = new TUndoRedoState(Sender);  
}

Dans le premier cas, bien penser à libérer la mémoire avec un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

delete FUndoRedo,

dans le FormDestroy.

[luiso]

Bonjour getz85,

Je viens d'essayer mais l'une comme l'autre, j'obtiens:

[BCC32 Erreur] Unit2.cpp(38): E2352 Impossible de créer une instance de la classe abstraite 'TUndoRedoState'
[BCC32 Erreur] Unit2.cpp(38): E2353 La classe 'TUndoRedoState' est abstraite parce que '_fastcall TUndoRedoState::BeginModify() = 0'

Pour pouvoir compiler au début j'avais modifié: le HPP:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
#ifndef UndoredostateHPP
#define UndoredostateHPP
 
#pragma delphiheader begin
#pragma option push
#pragma option -w-      // All warnings off
#pragma option -Vx      // Zero-length empty class member functions
#pragma pack(push,8)
#include <System.hpp>	// Pascal unit
#include <SysInit.hpp>	// Pascal unit
#include <_State.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <SysUtils.hpp>	// Pascal unit
 
//-- user supplied -----------------------------------------------------------
 
namespace Undoredostate
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TUndoRedoState;
class PASCALIMPLEMENTATION TUndoRedoState : public System::TObject
{
 typedef System::TObject inherited;
 
private:
	_state::_di_IState FState;
	Classes::TList* FUndoRedoList;
	int FModifyCount;
	int FUndoPos;
	Classes::TStream* FTailState;
	unsigned FMaxMemoryUsage;
	unsigned FCurrMemUsage;
	Classes::TStream* __fastcall CreateCurrentState(void);
	void __fastcall SetMaxMemoryUsage(const unsigned Value);
	void __fastcall TruncToMem(void);
 
public:
	__fastcall TUndoRedoState(_state::_di_IState AState);
	__property unsigned MaxMemoryUsage = {read=FMaxMemoryUsage, write=SetMaxMemoryUsage, nodefault};
	virtual void __fastcall BeginModify(void) =0 ;  // j'ai ajouter des "virtual" et "= 0"
	virtual void __fastcall EndModify(void) =0 ;    // pour que ca compile ...
	virtual void __fastcall Undo(void) =0 ;         // car a l'execution  ...
	virtual void __fastcall Redo(void) =0 ;         // ca plantait ?????
	__fastcall virtual ~TUndoRedoState(void);
};
//-- var, const, procedure ---------------------------------------------------
}	/* namespace Undoredostate */
#if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE)
using namespace Undoredostate;
#endif
#pragma pack(pop)
#pragma option pop
 
#pragma delphiheader end.
//-- end unit ----------------------------------------------------------------
#endif	// UndoredostateHPP

[ShaiLeTroll]

TUndoRedoState est une classe abstraite !
En gros, elle ne fait quasiment rien, elle offre juste un modèle de comportement
Soit tu trouves une implémentation qui hérite de TUndoRedoState, soit tu l'implémentes toi-même, ce que tu voulais semble-t-il éviter !

[luiso]

Bonsoir ShaiLeTroll,

Effectivement, j'avais surtout besoin de voir un exemple, afin de comprendre le fonctionement.

Car je ne me sent pas de le faire moi-même (j'ai essayé avec l'exemple en delphi mais nada pour la conversion...)

Si je ne trouve pas un vrai composant ou une classe en cbuilder exploitable pour mon niveau, j'abandonnerais.

C'est désolant de ne rien trouver en Cbuilder.

*-*

[luiso]

Bonjour,
-
Je ne lâche pas l'affaire, mais je vais faire sans le Composant Delphi...
-
J'ai créer un programme (basic) avec 1 ListeBox pour les positions de chaque image et un TImage, mais avec "Sauvegardes en BMP" des actions,
ce qui fait que le Disque dur est très sollicité, c'est ennuyeux.
Bien que ca fonctionne impécable.
-
Si une bonne âme voulait m'expliquer comment on utilise "Seek, Position et Size" avec "TMemoryStream", si possible un mini exemple pour aider
à la compréhension, car sur la doc CBuilder c'est dificile de comprendre.
J'ai essayé mais....
-
Je résume, je voudrais(comme dans un logiciel dessin):
1) Placer des images ou (portion de l'image modifiée) que je crée, en mémoire.
2) En cliquant sur 1 bouton(Undo): Pouvoir afficher chaque image
3) En cliquant sur 1 bouton(Redo): Pouvoir afficher chaque image

D'avance merci...

[ShaiLeTroll]

Plusieurs questions avec autant de thèmes différents ce n'est pas bien !

Si une bonne âme voulait m'expliquer comment on utilise "Seek, Position et Size" avec "TMemoryStream", si possible un mini exemple pour aider
à la compréhension, car sur la doc CBuilder c'est dificile de comprendre.
J'ai essayé mais....

Propose nous un code, imagine un TStream comme une Bande, une Cassette Audio (lol, tu connais ça, c'était le truc AVANT le CD qui lui même est le truc avant le MP3)

Seek c'est pour rembobiner ou pour avancer
Position c'est l'endroit où tu es !
Size c'est la taille du stream !
Write écrit un buffer à l'endroit en cours (Position) et avance de la taille du buffer, ainsi les écritures se font les unes après les autres sans se poser de question, comme si tu empilais de briques ...
Read fonctionne comme Write, cela lit le buffer et avance la Position
Il n'y a rien de compliquer !

Ensuite Image->LoadFromStream, utilise Read, le format d'une image étant cohérent, si ton stream contient 4 images qui se suivent, tu dois pouvoir appeler 4 fois LoadFromStream !

Pose 8 TImage sur une Fenêtre, un bouton et utilise ce code !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
void __fastcall T...::Button1Click(TObject *Sender)
{
  Image1->Canvas->Pen->Color = clRed;
  Image1->Canvas->Brush->Color = clBlue;
  Image1->Canvas->Rectangle(0, 0, 20, 20);
  Image2->Canvas->Pen->Color = clYellow;
  Image2->Canvas->Brush->Color = clGreen;
  Image2->Canvas->Rectangle(5, 5, 25, 25);
  Image3->Canvas->Pen->Color = clGreen;
  Image3->Canvas->Brush->Color = clRed;
  Image3->Canvas->Rectangle(10, 10, 40, 50);
  Image4->Canvas->Pen->Color = clBlue;
  Image4->Canvas->Brush->Color = clYellow;
  Image4->Canvas->Rectangle(0, 15, 20, 25);
 
  TMemoryStream *Stream = new TMemoryStream();
  Image1->Picture->Bitmap->SaveToStream(Stream);
  Image2->Picture->Bitmap->SaveToStream(Stream);
  Image3->Picture->Bitmap->SaveToStream(Stream);
  Image4->Picture->Bitmap->SaveToStream(Stream);
 
  // On revient en arrière !
  Stream->Seek((__int64)0, soBeginning);
 
  Image5->Picture->Bitmap->LoadFromStream(Stream);
  Image6->Picture->Bitmap->LoadFromStream(Stream);
  Image7->Picture->Bitmap->LoadFromStream(Stream);
  Image8->Picture->Bitmap->LoadFromStream(Stream);
 
}

Je résume, je voudrais(comme dans un logiciel dessin):
1) Placer des images ou (portion de l'image modifiée) que je crée, en mémoire.
2) En cliquant sur 1 bouton(Undo): Pouvoir afficher chaque image
3) En cliquant sur 1 bouton(Redo): Pouvoir afficher chaque image

Utilise une TObjectList et TBitmap, tu pourras ainsi historiser tes images !
Dans la ListBox d'historique, n'affiche pas l'image, gère une TImageList que tu remplis manuellement avec des miniatures (32x32) de l'image réel ...


PhotoShop utilise son propre fichier d'échange, il utilise bcp le disque !
En fait, il vaut mieux gérer son propre cache et être conscient des performances de celui-ci que de laisser toute ne mémoire (et que windows fasse son SWAP)
Il faut penser qu'avant 128Mo on pouvait tourner sous Win98 avec Delphi 4 et PhotoShop manipulant des images 1024x768 avec 20 plans superposés !

[luiso]

Bonjour ShaiLe Troll;

Voila ou j'en suis... apres je ne sais plus...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 * Form1;
TMemoryStream *RTMS = new TMemoryStream;
bool FMouseDown;
TRect CopSav;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
}
//-------------------------------------------------
void __fastcall TForm1::FormDestroy(TObject * Sender)
{ // Libère la mémoire
  RTMS->Clear();  delete RTMS;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject * Sender)
{ // Prépare l'image
 ImageVue->Picture->Bitmap->Width = ImageVue->Width;
 ImageVue->Picture->Bitmap->Height = ImageVue->Height;
 RTMS->Position = 0;  //position 1ere image
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ImageVueMouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y)
{ // Dessine à main nue (fait pour l'essai undo redo)
 if(FMouseDown==true)      return;
 CopSav.Left = X; CopSav.Top = Y; // coordonnées de début de la portion à sauver
 FMouseDown = true;
 ImageVue->Canvas->MoveTo(X, Y);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ImageVueMouseMove(TObject *Sender, TShiftState Shift, int X, int Y)
{   // Dessine à main nue
 if(FMouseDown) ImageVue->Canvas->LineTo(X, Y);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ImageVueMouseUp(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y)
{ // Bouton souris relaché on enregistre l'image
  CopSav.Right = X; CopSav.Bottom = Y;  // coordonnées de fin de la portion à sauver
  Ajoute();
  FMouseDown = false;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Ajoute()
{  // PROCEDURE de sauvegarde d'images ????????
 RTMS->Position = 0;
 ImageVue->Picture->Bitmap->SaveToStream(RTMS);
 RTMS->Seek(0, soFromBeginning);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Undo1Click(TObject *Sender)
{  // Undo   // Affiche la 1ere image du stream
 RTMS->Position = 0;
 RTMS->Seek(0, soFromBeginning);
 ImageVue->Picture->Bitmap->LoadFromStream(RTMS);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Redo1Click(TObject *Sender)
{ // Redo
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{ //efface l'image  uniquement pour les essais
 ImageVue->Canvas->FillRect(TRect(0,0,ImageVue->Width,ImageVue->Height));
}
//---------------------------------------------------------------------------

[ShaiLeTroll]

Je te l'avoue, je n'ai pas envie de lire ton code !
Rien que voir RTMS en variable globale initialisé en direct et libéré dans le OnDestroy alors que la logique (pour être rigoureux) cela devrait être dans le constructor ou dans le OnCreate !
RTMS devrait être un membre privé de Form1 !

Je ne lâche pas l'affaire, mais je vais faire sans le Composant Delphi...

Dommage de ne pas hérité de TUndoRedoState ton gestionnaire de UndoRedo que tu pourrais appeler TImageHistoric par exemple !
Il te donne un cadre POO pour structurer ton développement !
Tu confonds utilisation et implémentation !

Tu nous lâches TA problématique comme ça en nous sortant un "apres je ne sais plus"
On veut bien t'aider mais il nous fait des Questions !

Il faut que tu analyses le problème, que tu trouves les données et les traitements tu pourrais ensuite structurer ton code avec des classes !

Sort ton Stylo et une feuille ! Gribouille un Diagramme de Séquence !

Le Stream n'est pas la solution à mon avis !

Une TObjectList de TBitmap sera plus simple à manipuler, tu ajoutes et lors du Redo, suffit de remonter (tu mémorises l'index, tu pourras ainsi défaire et refaire)

[luiso]

0) Vous avez bien fait de ne pas lire mon code, les débuttants sont tellement mauvais, LOL!.
1) Mon thème reste toujours le même "Undo Redo".
2) Evidemment que mon exemple est pas tres bien écrit, mais j'ai fais ce que j'ai pu en tant que petit "DEBUTANT"...
Si j'avais plus de pratique je ne serais pas là à demmander, et, si la doc plus que m....... de Cbuilder ne m'a pas aidé,
je ne vois pas comment des conseils sans un mini exemple pourrait le faire.
J'avais juste besoin de savoir comment placer et employer Position, Size, Seek à l'aide d'un mini exemple.
(Les images n'ayant pas toutes la même tailles je n'arrive pas à les additionner et ensuite les retrouver)
-
3) Le déroulement du programme je pense que je l'ai tres bien compris puisque mon Undo-Redo, je l'ai bien réussi mais sur disque dur.
Alors que je le voulais en mémoire.
-
4) De plus il est vrai que si l'on dépasse un certains nombre de portions en mémoire, ca risque peut-être de ralentir ???
Alors qu'avec les gros DD actuels on a de la marge.
C'est pourquoi, je pense que je vais conserver ma solution "disque dur" puisque le reste me parrait réservé à l'"élite".
-
5) Quand au "TUndoRedoState composant invisible pour Delphi, apres traduction il ne fonctionne pas en builder, quelques finesses de conversion
sans doute font que je ne n'arriverais jamais à trouver le pourquoi en tant que "débutant".
-
Merci,
toutefois pour cette aide précieuse qui m'a permi de comprendre qu'il fallait être bien dégrossi pour avoir droit à une aide assimilable par un debutant.
C'est vrai que je ne suis peut-être pas sur le bon forum "Forum des professionnels en informatique" il me faudrait trouver "Forum des débuttants en informatique", pour pauser mes questions idiotes.
*** Toutefois ne pas oublier que si il n'y avait pas eu de "débutants" il n'y aurait jamais eu de "pros".

[ShaiLeTroll]

Lit toute ma réponse, n'oublie pas, je suis un méchant TROLL !
Lorsque j'écris, je peux paraître agressif, je te le confirme, c'est pour vous secouer les neurones !
Je ne suis pas là pour réconforter les futurs développeurs médiocres dans leur ignorance ...
tu es débutant, tu es peut-être un futur génie ! Faut juste le travailer !

0) Vous avez bien fait de ne pas lire mon code, les débuttants sont tellement mauvais, LOL!.

J'ai été débutant !

tu es inscrit depuis mars 2009,

Si tu es un étudiant en informatique ou un futur Pro, tu ne fait que ça donc depuis au moins 2 ans, à ce moment là de mon cursus universitaire, je venais de commencer le projet de pilotage d'un robot en temps réel (Socket, Pointer et packed record, Thread et les problèmatiques de partage de données...)
le Stream, le TFileStream, ie l'ai utilisé aussi à ce moment !
Avant j'utilise exclusivement BlockRead\BlockWrite (ça je l'ai appris à mon second stage en entreprise, je tapais mon code à deux doigts, les cours avait commencé un mois auparavant)


Si tu es un autodidacte qui fait ça pour le divertissement, tu n'as effectivement pas le temps, la progression est plus lente et plus difficile car discontinue ! Bon courage !


Quand je ne savais pas, je cherchais, je bidouillais, je trifouillais, j'ai passé des heures à parcourir le code des Classes.pas et l'aide de Delphi 4 !
Il est vrai, pas de chance, C++Builder ne fourni pas de code mais juste les headers !

2) Evidemment que mon exemple est pas tres bien écrit, mais j'ai fais ce que j'ai pu en tant que petit "DEBUTANT"...
Si j'avais plus de pratique je ne serais pas là à demmander, et, si la doc plus que m....... de Cbuilder ne m'a pas aidé

la Doc Wiki C++Builder XE est surement la meilleure doc depuis 5 ans !
On arrive au niveau de celle de D7 !

J'avais juste besoin de savoir comment placer et employer Position, Size, Seek à l'aide d'un mini exemple.
(Les images n'ayant pas toutes la même tailles je n'arrive pas à les additionner et ensuite les retrouver)

As-tu vraiment lu ma réponse ?
As-tu vraiment analysé mon exemple ?
As-tu cherché à comprendre le Stream ?
As-tu cherché à comprendre le TBitmap et son LoadFromStream ?
Non !
Tu n'as pas à trouver les images !
LoadFromStream les trouvent tout seul !
Le format d'un TBitmap lui permet de savoir sa taille pour tu puisses les empiler et dépiler facilement, ça c'est pour une FIFO

Pour un accès aléatoire, Un Array of Integer pour sauvegarde le début de chacune (Position AVANT le SaveToStream) et le tour est joué !
Encore une fois, il faut chercher !
Je te l'ai dit "Stylo + Papier" !

Je ne sais pas quelle version de XE,
As tu la chance d'avoir "classes.pas" ?
Oui, alors tu as le code pascal, tu aurais vu de la gestion mémoire de le TMemoryStream, certe ce n'est pas du C++, mais un "PRO" doit savoir s'adapter !
Et en C++Builder, je pense qu'il faut savoir lire du Delphi !
C'est comme vouloir construire une maison mais savoir où acheter les briques !

Il me semble que les sources Pascal ne sont fournis qu'en version Pro ou plus ?
N'ayant jamais utilisé de version Perso ou Starter, je l'ignore !

Mais je t'ai dit que le Stream n'était pas adapté alors qu'une TObjectList et des TBitmap seront plus facile à manipuler !
D'ailleurs la plupart des débutants aurait choisi un "array[1..100] of TBitmap", tu as fais preuve d'originalité ! BIEN !

En poussant plus loin, une TObjectList pouvant contenir soit des TBitmap donc en mémoire, soit des TFileStream donc du fichier, en utilisant les bons concepts POO, on peut faire quelque chose de très ouvert !

4) De plus il est vrai que si l'on dépasse un certains nombre de portions en mémoire, ca risque peut-être de ralentir ???

Avec les machines actuels de 2 à 8Go, tu n'as pas à t'inquièter avant 500 images HD WUXGA

Alors qu'avec les gros DD actuels on a de la marge.
C'est pourquoi, je pense que je vais conserver ma solution "disque dur" puisque le reste me parrait réservé à l'"élite".

L'avantage du disque c'est qu'un Redo\Undo, ce n'est pas des informations cruciales, une vrai solution "elite" serait de mixer mémoire\DD, avec un cache de 5 images en mémoire et les autres en DD ...

toutefois pour cette aide précieuse qui m'a permi de comprendre qu'il fallait être bien dégrossi pour avoir droit à une aide assimilable par un debutant.
C'est vrai que je ne suis peut-être pas sur le bon forum "Forum des professionnels en informatique" il me faudrait trouver "Forum des débuttants en informatique", pour pauser mes questions idiotes.[
*** Toutefois ne pas oublier que si il n'y avait pas eu de "débutants" il n'y aurait jamais eu de "pros".

C'est juste que l'on a trop de débutant qui attendent la becquée !!!
Ce qui est utile pour un débutant n'est pas une solution prête à l'emploi mais une démarche, savoir comment chercher, savoir lire l'aide !

[MODE TROLL ++]
Ne pas comprendre l'objet Stream, je suis désolé, c'est un basique !
Pour moi, c'est le signe que l'on est pas fait pour le métier !
[MODE TROLL --]

[luiso]

Carte ID:
1) 66 ans inscrit depuis moins de 2 ans.
2) Pas souvent sur une machine, à part depuis ce début d'année.
3) Il faut d'abord profiter du temps qu'il me reste avant tout.
4) Mais je goute à toutes les nouveautées aléchantes, bien que j'ai du mal à tout saisir quelquefois.
5) Dans mon temps on donnait de petits exemples avec les discussions sur les choses que l'on voulait faire, et l'on comprenait plus rapidement.
Car rien ne vaut un bon dessin à de grands discours.
-
Le gentil bon vieu nain de jardin.

[ShaiLeTroll]

66 ans inscrit depuis moins de 2 ans.

Mars 2009 - Juillet 2011, ça fait 2 ans et 3 Mois donc plus

Excuse, on a une vague de stagiaire qui découvre que le métier est plus dur que ce que l'on apprend dans les universités !
Et que maintenir un code qui a été touché par une dizaine de développeur pendans des années ayant chacun leur style est le vrai quotidien du métier et que c'est parfois pénible car tout s'écroule dès que l'on souffle dessus !

En tout cas, ça change tout, tu es amateur, tu n'as donc pas appris les concepts de la programmation POO, c'est en fait un délire structurel pour informaticien prétentieux (eh oui, j'en suis un)
C'est pour cela que Héritage, abstraction, implémentation, ça ne te disait rien !
Pour TUndoRedoState, je n'avais pas compris mais c'est toi qui mis virtual ! tu voulais nous embrouiller !
Je ne connais pas cette classe ! je ne l'ai pas !
En fait, il te manquait un OBJ ou DCU, tu n'aurais pas du nous montrer ta correction mais plutôt nous parler du problème en amont qui devait être du genre "Erreur Link - fonction BeginModify non trouvé dans ..."

J'aurais du expliqué avec un Vinyle et son diamant !

.
5) Dans mon temps on donnait de petits exemples avec les discussions sur les choses que l'on voulait faire, et l'on comprenait plus rapidement.
Car rien ne vaut un bon dessin à de grands discours.

J'ai donné une exemple avec les 8 TImage et pour mon test, d'instinct, j'avais mis des dimensions différentes pour les 2 séries pour justement observé ce phénomère de Lecture "intelligente" du LoadFromStream !


Sinon, un conseil, si tu le peux, utilise Delphi et non C++Builder !
La syntaxe est plus facile, les composants de toute façon sont tous écrit en Delphi même ceux utilisé par C++Builder
La gestion des fichiers est plus simple (pas tout ce délire de .h, .cpp et l'édition des liens chiante au possible)
En plus, la compilation est plus rapide !

[luiso]

Il est ou cet exemple ?

J'ai donné une exemple avec les 8 TImage et pour mon test, d'instinct, j'avais mis des dimensions différentes pour les 2 séries pour justement observé ce phénomère de Lecture "intelligente" du LoadFromStream !


Désolé je ne l'avais pas vu, je l'ai trouvé...

[luiso]

En fait le problème serait; comment faire apparaitre une image aprés l'autre
dans l'image 5 par exemple à chaque fois que l'on clique sur Arrière.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
  Image1->Canvas->Pen->Color = clRed;
  Image1->Canvas->Brush->Color = clBlue;
  Image1->Canvas->Rectangle(0, 0, 20, 20);
  Image2->Canvas->Pen->Color = clYellow;
  Image2->Canvas->Brush->Color = clGreen;
  Image2->Canvas->Rectangle(5, 5, 25, 25);
  Image3->Canvas->Pen->Color = clGreen;
  Image3->Canvas->Brush->Color = clRed;
  Image3->Canvas->Rectangle(10, 10, 40, 50);
  Image4->Canvas->Pen->Color = clBlue;
  Image4->Canvas->Brush->Color = clYellow;
  Image4->Canvas->Rectangle(0, 15, 20, 25);
  Image1->Picture->Bitmap->SaveToStream(Stream);
  Image2->Picture->Bitmap->SaveToStream(Stream);
  Image3->Picture->Bitmap->SaveToStream(Stream);
  Image4->Picture->Bitmap->SaveToStream(Stream);
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::ArriereClick(TObject *Sender)
 
{ //  On revient en arrière !
  N++;
  Stream->Seek((__int64)0, soBeginning);
  Image5->Picture->Bitmap->LoadFromStream(Stream);
  /*Image6->Picture->Bitmap->LoadFromStream(Stream);
  Image7->Picture->Bitmap->LoadFromStream(Stream);
  Image8->Picture->Bitmap->LoadFromStream(Stream); */
}
//---------------------------------------------------------------------------

[ShaiLeTroll]

C'est là le problème du Stream et du TBitmap !
Quelle est la taille en octet de la Bitmap ?
Soit tu te lance dans les API et le Header du BMP, tu as plein d'exemple à ce sujet !
Soit, tu gères un Index, utilisons un "std::vector StreamIndexes"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
  ...
  Image4->Canvas->Rectangle(0, 15, 20, 25);  
  StreamIndexes.insert(Stream->Position);
  Image1->Picture->Bitmap->SaveToStream(Stream);
  StreamIndexes.insert(Stream->Position);
  Image2->Picture->Bitmap->SaveToStream(Stream);
  StreamIndexes.insert(Stream->Position);
  Image3->Picture->Bitmap->SaveToStream(Stream);
  StreamIndexes.insert(Stream->Position);
  Image4->Picture->Bitmap->SaveToStream(Stream);
 
  LastImageIndex = StreamIndexes.size() - 1;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
{ //  On revient en arrière !
  __int64 LastPos = StreamIndexes.back();
  Stream->Seek(LastPos, soBeginning);
  Image5->Picture->Bitmap->LoadFromStream(Stream);
  Stream->Size = LastPos; // Tronque le Stream
  StreamIndexes.pop_back(); // retire l'index
}

ou encore

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
{ //  On revient en arrière !
  __int64 LastPos = StreamIndexes[--LastImageIndex];
  Stream->Seek(LastPos, soBeginning);
  Image5->Picture->Bitmap->LoadFromStream(Stream);
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
{ //  On va en avant !
  __int64 LastPos = StreamIndexes[++LastImageIndex];
  Stream->Seek(LastPos, soBeginning);
  Image5->Picture->Bitmap->LoadFromStream(Stream);
}

Soit, une TObjectList ...

[luiso]

Bonjour,

J'ai donc ajouté:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

#include <vector>

et placé:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

std::vector StreamIndexes;

Mais:

[BCC32 Erreur] Unit2.cpp(37): E2102 Impossible d'utiliser le template 'std::vector<_Ty,_Ax>' sans spécifier des paramètres de spécialisation
Contexte d'analyseur complet
Unit2.cpp(20): analyse : void _fastcall TForm2::Button1Click(TObject *)

'std::vector<_Ty,_Ax>..... ?????

[ShaiLeTroll]

Comment créer et utiliser un tableau avec std::vector ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

std::vector<__int64> StreamIndexes;

C'est du C++ standard et sa STL = Standard Template Library !
Quand même, faudrait chercher un petit peu avant de répondre !
Comme toi, il y a 6 mois, je débutais en C++, je ne savais pas ce qu'était une "template C++", j'ai cherché à les utiliser en lisant FAQ et l'aide fourni dans C++Builder, la STL étant fourni par Dinkumware !

[luiso]

J'avais essayé ca aussi

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

std::vector<__int64> StreamIndexes;

mais c'est pareil...

[BCC32 Erreur] Unit2.cpp(45): E2285 Impossible de trouver une correspondance pour 'std::vector<__int64,std::allocator<__int64> >::insert(__int64)'
Contexte d'analyseur complet
Unit2.cpp(25): analyse : void _fastcall TForm2::Button1Click(TObject *)

[ShaiLeTroll]

Peut-être que le type __int64 n'est pas apprécié, essaye int, après tout tu n'auras pas plus de 2Go d'image en RAM

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

std::vector<int> StreamIndexes;