CBuilderXE Uno Redo Manager ?

**luiso** · 22/06/2011, 15h57

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** · 22/06/2011, 16h21

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** · 22/06/2011, 16h34

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** · 22/06/2011, 16h59

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** · 22/06/2011, 17h19

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** · 07/07/2011, 16h03

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...

CBuilderXE Uno Redo Manager ?

C++Builder

Vue hybride

Discussions similaires

Partager

Partager