déplacement des Timage créées dynamiquement

**bhahmed** · 18/08/2006, 18h42

salut,
j'ai créé des Timage dynamiquement dans un panel et j'aimerai les faire déplacer avec la sourie;
j'ai réussi à faire déplacer des timage créées d'une manière statique mais j'ai pas pu réussir l'autre.
en plus j'aimerai faire des liaison entre les images. j'ai crée un paintbox pour tracer les lignes mai je ne sai pas comment extraire les nouveaux coordonnées des Timages.
ci- joint mon code de déplacement des images statiques :

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
void __fastcall TForm1::Image2MouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
  MoveFlag = true;
Movex = X;
Movey = Y;
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::Image2MouseMove(TObject *Sender, TShiftState Shift,
      int X, int Y)
{
 if(MoveFlag)
{
Image2->SetBounds( Image2->Left + X - Movex,
Image2->Top + Y - Movey,
Image2->Width,
Image2->Height);
}
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::Image2MouseUp(TObject *Sender, TMouseButton Button,
      TShiftState Shift, int X, int Y)
{
 MoveFlag = false;
}
//---------------------------------------------------------------------------

et voici le code de la création dynamique des Timage :

Code :

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

1
2
3
4
5
6
7
8
9
10
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Graphics::TIcon *rond1 = new Graphics::TIcon();
rond1->LoadFromFile("D:\\Mes images\\PFE\\cpu\\PC1.ico");
 
 
image1->Picture->Icon->Assign(rond1);
image1->Parent = Panel1;
 
}

**Mattetfamilly** · 18/08/2006, 19h00

Méthode bourin:
tu déclares un tableau de TImage dans tes variables globales:
TImage *MyImages[25]; //25 étant alors le nombre maxi d'image que tu vas créer dynamiquement... Tu peux ajuster cette valeur en fonction de tes besoins.

En revanche attention avec ton code, cela signifie que tes variables existantes deviennent des tableaux...

**bhahmed** · 18/08/2006, 19h24

j'ai déclaré le Timage comme ça :

Code :

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

1
2
3
4
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
image1 = new TImage(Form1);

il faut donc juste changer cette déclarartion.
et pour les déplacer y t'il une solution
Merci

**henderson** · 18/08/2006, 20h44

Salut !

En fait, si j'ai bien compris ce que tu cherches à faire, tu peux gérer chaque image avec une même méthode pour chaque événement.
Il faut pour celà, affecter ces méthodes aux Images lors de leur création.
Voici un exemple de code pour la création dynamique et autant utiliser un TList.

L'astuce consiste à travailler au niveau du Sender qui est un pointeur sur l'objet qui a sollicité la méthode.
Voici tes méthodes et la modification qu'il faut y apporter :

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
//---------------------------------------------------------------------------
void __fastcall TForm1::Image2MouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
//...inchangé
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::Image2MouseMove(TObject *Sender, TShiftState Shift,
      int X, int Y)
{
if(MoveFlag)
    {
    TImage *Image = (TImage*)Sender; // << le sender est notre image
    Image->SetBounds(Image->Left + X - Movex, 
                     Image->Top + Y - Movey, 
                     Image->Width,
                     Image->Height);
    }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Image2MouseUp(TObject *Sender, TMouseButton Button,
      TShiftState Shift, int X, int Y)
{
//...inchangé
}
//---------------------------------------------------------------------------

Code :

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

TList *Images = new TList;

Le code pour la création des images :

Code :

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

1
2
3
4
5
6
7
8
TImage *Image = new TImage(this); //this (Form1) ou Panel1 au choix...
Image->Parent = Panel1;
//Affectation des méthodes
Image->OnMouseDown = Image2MouseDown;
Image->OnMouseMove = Image2MouseMove;
Image->OnMouseUp   = Image2MouseUp;
//... le reste de l'initialisation...
Images->Add(Image);

Il ne faudra pas oublier de libérer la liste, dans la OnClose de Form1, sans
pour autant détruire les images puisque c'est leur propriétaire (Form1 ou le panel)
qui s'en chargera :

Code :

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

1
2
Images->Clear();
delete Images;

pour accéder aux images depuis la liste :

Code :

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

1
2
3
4
5
6
TImage *Image;
for(int j = 0; j < Images->Count; j++)
    {
    Image = (TImage*)Images->Items[j];
    //... s'il y a quelque chose à faire sur l'image....
    }

A plus !

**ero-sennin** · 18/08/2006, 21h18

La méthode d'henderson est celle que j'ai utilisé (en delphi) pour faire exactement la même chose que toi bhahmed, et ca fonctionne très bien !
Par contre, moi je n'ai pas créé de TList... je ne vois pas trop à quoi ca sert en faite ...

Voilà
@ +

**bhahmed** · 18/08/2006, 21h38

ero-sennin qu'est ce que tu as fais alors ?

**bhahmed** · 18/08/2006, 21h54

A henderson ,
merci ça marche très bien mais pour l'intialisation de la list et son utilisation je l'ai pas bien compri. ainsi le delette des images me crée des erreurs.

Merci bien

**ero-sennin** · 18/08/2006, 22h01

Le projet que je fais, c'est de faire un MEA. Je crée des TImages (de façon dynamique) qui représenteront des Entités et qui pourront être déplacé à la souris.

J'ai crée des procédures pour le EntiteOnMouseDown, EntiteOnMouseUp, etc ... qui sont utilisées à la création de mon TImage... mais Henderson à tout dit donc je ne pense pas que ca valle le coup de tout décrire etc ...

Je ne poste pas de code car c'est en delphi, mais si tu es intéressé, je peux t'envoyer en MP le bout qui gère le déplacement (je répéte, en delphi

)

@ +

**bhahmed** · 18/08/2006, 22h12

merci,
mon projet consiste à faire une interface pour représenter l'architecture d'un réseau ( poste, routeur, Fw, switch) très emblable à routersim.
j'ai réussi à créer les images dynamiques mais reste comment avoir les positions de chaques image et comment les relier entre eux pour compléter l'architecture du réseau
encore Merci.

**ero-sennin** · 18/08/2006, 22h22

Pour savoir la position de tes TImages, tu codes une procédure du genre

Code :

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

1
2
procedure TFPrincipale.EntiteOnMouseDown(Sender: TObject;
  Button: TMouseButton; Shift: TShiftState; X, Y: Integer);

pour la déclaration dans le .h (désolé ca reste encore du Delphi).

Puis voici comme elle devrait être dans le .cpp (toujours en delphi) :

Code :

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

1
2
3
4
5
6
7
procedure TFPrincipale.EntiteOnMouseDown(Sender: TObject;
  Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
 
if (Button=mbLeft) then
   EntiteSelectionnee:=TImage(Sender);
end;

Grâce à cela, tu peux accéder aux propriétés du TImage cliqué ... Donc, tu connais sa position (EntiteSelectionnee.Left), ses dimensions etc etc ...

J'espère que je t'embrouille pas de trop

**henderson** · 19/08/2006, 11h11

Salut !

Est-ce qu'un tel projet ne mérite pas une réflexion plus approfondie ?
Pour ce type de développement, je ne suis pas certain que l'usage des TImage soit une bonne solution même si elle semble être la plus simple pour ce qui est de l'aspect événementiel.
Il ne faut pas négliger les effets de scintillement lors du déplacement des objets de la VCL.
Un TImage est conçu pour représenter une image et non pas pour être manoeuvré (glisser/déposer).

Ca vaut le coup de modéliser un objet doté de mécanismes pour :
- se dessiner et dessiner ses liens vers d'autres objets,
- prendre de focus,
- calculer son état qui peut dépendre de l'état des autres (ici je ne sais pas si c'est utile ???).

C'est ce que je fais dans mes propres réalisations :
- simulation logique (circuits intégrés vus d'en haut, LEDs, Afficheurs, Dip Switches etc...) donc avec des connexions dessinées d'une manière intelligente
- modélisation audio (DCO, VCA, etc...)

Ce n'est pas la mer à boire d'autant plus qu'une bonne modélisation (pour ne pas dire objétisation) permet de bien regrouper les choses et donc d'avoir une vision plus claire de ce que l'on développe !

A plus !

**ero-sennin** · 19/08/2006, 13h00

Je poste ma méthode concernant le déplacement de TImage créé dynamiquement

Voici le .h (en rouge c'est ce que j'ai ajouter) :

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

#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// Composants gérés par l'EDI
        TButton *BtnCreerImage;
        void __fastcall BtnCreerImageClick(TObject *Sender);
        void __fastcall ImageMouseDown(TObject *Sender,
          TMouseButton Button, TShiftState Shift, int X, int Y);
        void __fastcall ImageMouseMove(TObject *Sender, TShiftState Shift,
        int X, int Y);
        void __fastcall ImageMouseUp(TObject *Sender, TMouseButton Button,
      TShiftState Shift, int X, int Y);
        void __fastcall FormCreate(TObject *Sender);


private:	// Déclarations utilisateur
                bool Deplacer;
                int XClic,YClic;
                TImage *ImageSelectionnee;
public:		// Déclarations utilisateur
        __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

Et voici le .cpp :

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

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------


void __fastcall TForm1::BtnCreerImageClick(TObject *Sender)
{
  TImage *Image = new TImage(this);
  Image->Parent = Form1;
  Image->Width=100;//Largeur de 100
  Image->Height=150;//Hauteur de 150
  Image->Top=10;// Endroit de l'apparition de l'image crée en Y
  Image->Left=10;// Idem mais en X
  Image->Canvas->Brush->Color=clWhite;
  Image->Canvas->Rectangle(0,0,Image->Width,Image->Height);//Dessinee un rectangle de la dimension de l'image
  Image->OnMouseDown=ImageMouseDown;
  Image->OnMouseMove=ImageMouseMove;
  Image->OnMouseUp=ImageMouseUp;
}
//---------------------------------------------------------------------------

void __fastcall TForm1::ImageMouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
  ImageSelectionnee = (TImage*)Sender; // Le sender correspond à l'image cliquée
  Deplacer=true;
  XClic=X;
  YClic=Y;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ImageMouseMove(TObject *Sender, TShiftState Shift,
      int X, int Y)
{
   if (Deplacer)
   {
     ImageSelectionnee->Left=ImageSelectionnee->Left+(X-XClic);
     ImageSelectionnee->Top=ImageSelectionnee->Top+(Y-YClic);
   }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ImageMouseUp(TObject *Sender, TMouseButton Button,
      TShiftState Shift, int X, int Y)
{
  Deplacer=false;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{
  DoubleBuffered=true;// Pour supprimer les Scintillements
}
//---------------------------------------------------------------------------

Je pense qu'avec cela tu devrais comprendre

en plus des infos d'Henderson

@+

**bhahmed** · 20/08/2006, 22h38

merci ero-sennin de ce code mais je l'ai déja fai.
Mais j'ai pas bien saisie comment relier 2 Timages.

sinon pour Henderson tu me conseille d'utilsé quel type de composant ???

Merci pour votre aide

**ero-sennin** · 21/08/2006, 13h14

Salut

Pour relier 2 TImages entre eux, j'ai tracé une droite qui a pour point de départ le centre du premier TImage(1) sélectionné et comme point d'arrivé le centre du TImage(2) sélectionné.

Pour ce faire, j'utilise 2 TImages superposés qui seront de la dimension de ma fenêtre :
- 1 TImage de fond (qui aura par exemple la couleur blanche, bleue, ... ce que tu veux) qui restera vierge
- 1 TImage de dessin sur lequel tu vas tracer ta ligne.

Pourquoi un TImage de fond? Hé bien lorsque tu vas déplacer tes Timages créés de facon dynamique, il faudra bien supprimer la ligne tracée auparavant et redessiner la nouvelle ligne (vu que le centre de ton Timage dynamique change).

J'ai peut être fait compliqué avec les 2Timages, mais si tu n'as qu'une couleur de fond qui restera toujours blanche ou autre et que l'utilisateur ne pourra pas modifier dans le programme, alors 1 seul TImage ( celui de dessin) suffit!

J'ai l'impression que plus j'écris, plus je t'embrouille

Si tu as (ou n'as pas) compris, dis le

@+

**bhahmed** · 21/08/2006, 13h20

j'ai compris le principe mais bq tu ne fais pas un refrech si un Timage est déplacer dans ce cas tu aurra besoin qu'un seul Timage.
Et pour savoir le centre d'un Timage comment faire ? et comment je peux tracer la ligne en sélectionant l'image de départ et l'image de l'arrivée

Merci

**ero-sennin** · 21/08/2006, 15h52

J'ai besoin dans mon cas de 2 TImages car l'utilisateur à le choix pour la couleur de fond de mon application...

Ensuite, pour savoir le centre d'un TImage, je pense que c'est à ta portée

Ce ne sont que des maths, ni plus ni moins !

Allez, je te donne un petit exemple:

Code :

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

1
2
CentreX=Image1->Left+Image1->Width/2;
CentreY=Image1->Top+Image1->Height/2;

Pour tracer une ligne entre tes 2 rectangles, tu peux faire une petite fonction qui reçoit en paramètre le rectangle1 et le rectangle2.
Dans le MouseDown d'un TImage, tu rajoutes du code qui te permettra de récupérer le TImage de départ de celui d'arrivé de ce genre (Code non testé ...) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
if(RelierImage)
{
  if ((Image1Clic==false) and (Image2Clic==false)) 
  {
     ImageDepart=(TImage*)Sende;
     Image1Clic=true;
  }
  else
  if ((Image1Clic==true) and (Image2Clic==false))then
  {
    ImageArrivee=(TImage*)Sender;
    Image2Clic=true;
  }
}

Puis tu appelles ta fonction pour relier tes rectangles avec comme paramètres, ImageDepart et ImageArrivee, et tu remets Image1Clic et Image2Clic à false ...

J'espère que cela te mettra sur la voie

@+

**henderson** · 21/08/2006, 21h31

Salut !

Avec BCB on peut concevoir tout ce que l'on veut donc il ne faut pas s'en priver !
L'idée au départ est :
- ne pas mélanger des objets de la VCL avec du dessin de primitives
- éviter la redondance pour ce qui est de l'instanciation

Voici un exemple simple de classe permettant de créer un objet graphique, en dérivant de TComponent (au cas où...) :

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
enum{no_pin, input_pin, output_pin}; //renvoyé par la méthode PinHasFocus
 
class jObjet : public TComponent
{
public :
bool Selected; //Flag de sélection
TPoint Pos; //Position absolue (coin supérieur gauche du dessin de l'image)
TImage *Image; //pointeur vers son TImage dont on dessinera l'image
TList *Inputs; //Objets connectés en entrée
TList *Outputs; //Objets connectés en sortie
 
    __fastcall jObjet(TComponent *Owner, TImage *I, TPoint P);
    __fastcall ~jObjet();
 
//Méthodes de dessin
    void __fastcall Draw(TCanvas *C);
    void __fastcall DrawLinks(TCanvas *C);
 
//Méthodes pour la connexion
    void __fastcall Link(jObjet *Target);
    void __fastcall Unlink(jObjet *Target);
 
//Méthodes pour les tests de focus
    bool __fastcall HasFocus(TRect *R);
    int __fastcall PinHasFocus(TPoint *P);
};

Penses tu être capable à la lecture de cette classe d'en développer les méthodes ?

C'est une solution purement graphique qui au lieu d'utiliser des TImages en tant qu'objets distincts, ne va en utiliser que l'image qu'ils portent !

En aval, penses-tu pouvoir mettre en oeuvre tout l'événementiel depuis Form1 pour gérer ces objets ?

Je peux te donner un coup main si ce style de programmation t'intéresse.

A plus !

**henderson** · 22/08/2006, 13h34

Salut !

Pout faire suite, voici une démo qui utilise la classe décrite.

Le zip contient :
- un fichier TXT à lire
- un exe auto-suffisant développé avec BCB 3 Pro sur une machine sous W98 et dotée d'un simple P 233 MMX !

A plus !

**bhahmed** · 22/08/2006, 16h02

pour lier entre les Timage il faut ajouté cette^procédure

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void lier (void) 
{
Form1->PaintBox1->Refresh();
for (int i =0; i<eq; i++) {
for (int j=0; j<eq;j++) {
if (link [i][j] >=1) {
Form1->PaintBox1->Canvas->Pen->Width = link [i][j];
Form1->PaintBox1->Canvas->MoveTo(Image[i]->Left+Image[i]->Width/2,Image[i]->Top+Image[i]->Height/2 );
Form1->PaintBox1->Canvas->LineTo(Image[j]->Left+Image[j]->Width/2,Image[j]->Top+Image[j]->Height/2 );
 
}
}
}
}

puis faire l'appel danns le mouseup comme suit :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void __fastcall TForm1::Image1MouseUp(TObject *Sender, TMouseButton Button,
TShiftState Shift, int X, int Y)
{
TImage *Image = (TImage*)Sender;
if (imageDownButton == 0) {
MoveFlag = false;
lier();
Application->ProcessMessages();
} else {
link [chosenVehicule][Image->Tag] = 1;
link [Image->Tag][chosenVehicule] = 1;
lier();
}
}

déplacement des Timage créées dynamiquement

C++Builder

Discussions similaires

Partager

Partager