Discussion :

[pottiez]

Salut,
je voudrais faire un dynamic_cast en un type de classe que j'ai dans une string, mais je sais pas comment dire que le type est le contenu de cette string.
En gros je voudrais éviter de passer par une multitude de if qui test si la chaîne contient cette classe ou celle-ci, mais je ne sais pas si c'est passible.

[Crayon]

Dans le fond si je comprend bien, tu as une classe

Code :

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

1
2
3
4
5
class MaClasse
{
    private :
        int var1;
}

Ensuite une string:

Code :

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

1
2
AnsiString MaString;
MaString = "MaClasse";

Et tu cherches faire qqchose du genre:

Code :

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

instDeClasse = new MaString;

Alors si j'ai bien compris, je ne sais pas du tout comment faire

[pottiez]

en gros c'est ca, mais pas avec un new mais avec un dynamic_cast

exemple :

Code :

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

1
2
3
string maString = "TLabel*";
 
dynamic_cast<maString> Application->Components[0];

En sachant que bien entendu, dans maString il y aura le bon type du composant, qui aura été récupéré d'un fichier XML, grace au nom du composant (qui lui est accessible directement depuis TComponent)

[Sunchaser]

Bonjour,

Je ne sais pas si tu peut agir de la sorte directement dans le 'dynamic_cast'.
En revanche, une solution détournée peut être, si tu connais d'avance la liste des classes d'objets pouvant être 'castées'.
Je reprends l'astuce du 'Switch sur un AnsiString': ici

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
 
//global_test est un String définis ... qqpart ailleurs ;-)
   AnsiString Values[] = {"TLabel", "TMemo", "TEdit"};
   int tabSize = sizeof(Values) / sizeof(AnsiString);
for ( int i = 0; i < this->ComponentCount; i++ )
{
		switch(AnsiIndexStr(global_test, &Values[0], tabSize))
		{
			case 0: // "TLabel"
			{
				break;
			}
			case 1: // "TMemo"
			{
				TMemo* pmem = dynamic_cast < TMemo* > (this->Components[i]);
				if (pmem != NULL) {
					pmem->Lines->Add("essai cast");
				}
				break;
			}
			case 2: // "TEdit"
			{
				break;
			}
			default:
			break;
		}
}

En espérant t'aider,
@+

[blondelle]

Salut pottiez
Un lien dans la FAQ ce n'est pas exactement ce que tu cherche mais c'est une piste

http://cpp.developpez.com/faq/bcb/?p...ttrouverparnom

[pottiez]

Salut,
merci pour toute vos propositions, je voulais simplement éviter une multitude de if ou de case dans un switch, surtout que je ne sais pas forcément tout les types de composant.
Par contre (une idée comme ça), comme je veut accéder à une propriété qui est commune sur pratiquement tous les composants (le Caption pour ne pas le citer), je pourrai regarder la hiérarchie des classe Borland et caster sur la classe ou le Caption apparaît.

[Sunchaser]

Salut,

J'ai des questions:
. as tu accès au 'name' de l'objet ?
. si je comprends bien, tu peut récupérer la classe d'un objet dans un fichier XML, mais le code doit il agir sur une fenêtre que l'appli possède ou bien sur la fenêtre d'un application extérieure ?
. pas moyen de récupérer/tester directement un évènement de l'obet et d'avoir le 'Sender' par ex ...

Voili ... c'est fini
De mon côté, je continue de réfléchir avec mes petits moyens, z'aurez peut être trouvé bien avant.
@+

[Sunchaser]

Re,

Donc sinon une petite idée de début d'éventuelle solution:
-> en passant par 'API'

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
//en amont
String global_test = "TEdit";
//
String txt =  "test edit";
 
HWND hwnd = FindWindowEx(Handle, NULL, global_test.c_str(), NULL);
if (hwnd != NULL)
{
	SendMessage(hwnd, WM_SETTEXT, 0, (LPARAM)txt.c_str());
}

Cela suppose d'avoir le Handle de la fenêtre possédant l'objet recherché, etc ...

@+

[pottiez]

Salut,
je vais expliquer clairement ce que je voudrais faire, ça sera plus rapide

En fait, j'ai un fichier XML, dans lequel est enregistré des informations de tous les composants affichant du texte de mon appli. Je dispose des infos suivante: le name du composant, (la propriété Name d'un composant est directement accessible depuis la classe TComponent), le type du composant (TLabel, TGroupBox, TForm,...) et ces deux information sont suivie d'une liste de texte dans différentes langues (voila le but du projet).

Mon projet est donc de faire une classe, qui contiendra entre-autre une fonction qui prendra pour argument un TComponent, cette fonction changera le propriété texte dans la langue qui conviendra, puis fera une boucle sur tout les composants enfants du composant passé en argument, en appelant cette même fonction (récursive donc ).

Voila le projet, le seul souci est d'accéder à des propriété comme le Caption, ou tous autre propriété d'affichage de texte.

Je sais que le Caption est définit a partir de la classe TControl, mais il est en protected, donc non atteignable est cela jusqu'à ce que les composants soit définit eux même, donc pas de classe commun ou je pourrait l'atteindre.

Tous cela pour dire que au final, je vais devoir faire une succession de if ou de case, ce que je voulais éviter, mais bon, j'étais a peut près sur de devoir passer par la .

Merci tout de même pour vos recherche et votre aide .

[Gilles Louïse]

Vous pourriez passer par un tableau de pointeurs de fonctions (une fonction par type de composant) mais ça risque d'être une usine à gaz pour pas grand-chose, une série de if bien présentée me paraît plus claire ou un case prévu à cet effet.

Le tableau de fonctions n'est intéressant à mettre en oeuvre que si le nombre de composants différents était très grand, le jeu en vaudrait la chandelle, comme on dit. Sinon, ça me paraît une technique trop sophistiquée pour cette problématique.

À bientôt
Gilles

[Sunchaser]

Bonjour,

Donc tu as: le name, le classname, le/les types de propriétés a affecter, etc ...

Pffiou ... pleins d'infos, on devrait pouvoir y arriver. Pas sur que je sois forcement de bon conseil mais j'ai un bout de code/idée a proposer:
.h:

Code :

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

1
2
3
private:
void __fastcall ChangeProp(String Class_Name, String Object_Name, String Property_Name, String AValue);

.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
 
void __fastcall TForm2::ChangeProp(String Class_Name, String Object_Name, String Property_Name, String AValue)
{
try
{
HWND hwnd = FindWindowEx(Handle, NULL, Class_Name.c_str(), Object_Name.c_str());
	if (hwnd != NULL)
	{
		TControl *pControl = dynamic_cast < TControl* > (FindControl(hwnd));
		if (pControl != NULL) {
			try
			{
				SetPropValue(pControl, Property_Name, AValue);
			}
			catch(EPropertyError &propError)
			{
				//catcher l'erreur sur propriété non dispo
			}
		}
		else
		{
			//pControl est null
		}
	}
	else
	{
		// hwnd est null
	}
}
catch(...)
{
 
}
}

NB: j'ai retrouver l'idée du GetPropValue et SetPropValue dans un vieux post, qui remonte - imaginez vous bien - a l'époque ou Maître GreyBird fréquentait les lieux ! ( ) -> ici

J'ai une idée peut être un peu barbare: j'imaginerais passer en paramètre - pour la propriété a affecter - plutôt que de ne passer qu'un seul nom de propriété un tableau avec les éventuelles propriétés a affecter ('Text', 'Caption', etc).
Si ca plante sur le premier élément, on passe avec le EpropertyError dans le catch et on peut tester sur le second ...
Bon, un peu sauvage comme truc. Mais si tu as peu de cas, pourquoi pas ?

Donc tu lis le fichier XML, tu récupères et stockes en liste les classes et les noms d'objets, tu parcours la liste et fait appel a la fonction en passant les différents paramètres, etc ...

NB2: je ne manipule pas très bien les infos de RTTI et cie, donc il y a peut être un moyen de faire mieux ...

Voili
++

[Sunchaser]

Sorry,

Je poste vraiment n'importe quoi, désolé.
Je proposerais de virer l'utilisation de FindWindowEx, et de ne faire qu'ainsi:

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
 
void __fastcall TForm2::ChangeProp(String Object_Name, String Property_Name, String AValue)
{
try
{
		TControl *pControl = dynamic_cast< TControl* > (FindComponent(Object_Name));
		if (pControl != NULL) {
			try
			{
				SetPropValue(pControl, Property_Name, AValue);
			}
			catch(EPropertyError &propError)
			{
				//catcher l'erreur sur propriété non dispo
			}
		}
		else
		{
			//pControl est null
		}
	}
catch(...)
{
 
}
}

Donc dans ce cas, plus vraiment besoin de l'info concernant le nom de la classe.
J'ai testé avec des objets du type TLabel, TEdit, il faut voir avec d'autres objets possédant "Text" et/ou "Caption". D'ailleurs a ce propos, TLabeledEdit possède les deux si je ne me trompe pas ... mince, comment on fait ?

[blondelle]

Salut
Sur le site il y a un article sur RTTI, si ca peu aider

http://laurent-dardenne.developpez.c...s/Delphi/RTTI/

[pottiez]

Merci pour toute c'est infos, je testerai ce soir, car la je n'ai pas trop le temps.

Le xml je pensé le faire de la structure suivante :

Code xml :

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
<?xml version="1.0" encoding="iso-8859-1"?>
    <Traductions>
        <Langues>
            <Langue index="FR" name="Français" default="0" />
            <Langue index="EN" name="Anglais" default="1" />
            <Langue index="IT" name="Italien" default="0" />
            <Langue index="ES" name="Espagnol" default="0" />
        </Langues>    
        <Labels>
            <Nom du composant Type="TLabel">
                <Caption>
                    <FR>"Texte"</FR>
                    <EN>"Texte"</EN>                  
                    <IT>"Texte"</IT>
                    <ES>"Texte"</ES>
                </Caption>
                <Text>
                    <FR>"Texte"</FR>
                    <EN>"Texte"</EN>
                    <IT>"Texte"</IT>
                    <ES>"Texte"</ES>
                </Text>
            </Nom du composant>
    </Labels>
</Traductions>

<Langues> : Définit les langues contenu dans le fichier.
<Langue> : attributs de chaques langues
index : balise correspondante dans le fichier.
name : nom de la langue, qui figurera dans le menu de choix de langue.
default : 1 : langue par defaut, 0 sinon

<Label> : Contient les différents texte pour chaque propriété de chaque composants dans chaque langue
<Nom_du_composant> : contient les propriétés d'un composant
Type : Type du composant (TLabel, TEdit, TGroupBox,...)
<Caption> : conient le contenu dans chaque langue de la propriété Caption
<Text> : conient le contenu dans chaque langue de la propriété Text
...

Donc je peut tester si les propriétés disponibles dans le xml, et y accéder directement, il n'y en a pas tellement, en tout cas moins que de composant

[Sunchaser]

Re moi ...

Donc, même si je pense qu'avec ce que tu viens de décrire, tu as largement de quoi tester et agir sur le bon 'couple' objet/propriété, j'ai cherché tout de même a vérifier si la propriété passée en paramètre (du moins son nom) était bien une propriété de l'objet cible.
Cela donnerait:

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
 
void __fastcall TForm2::ChangeProp(String Object_Name, String Property_Name, String AValue)
{
try
{
		TControl *pControl = dynamic_cast< TControl* > (FindComponent(Object_Name));
		if (pControl != NULL)
		{
			TPropInfo **propList;
			int propcount = GetPropList(pControl, propList);
			for (int i = 0;i < propcount; i ++)
			{
				if (propList[i]->Name.operator AnsiString()== Property_Name)
				{
					try
					{
						SetPropValue(pControl, Property_Name, AValue);
					}
					catch(EPropertyError &propError)
					{
						//catcher l'erreur sur propriété non dispo
					}
				}
			}
		}
		else
		{
			//pControl est null
		}
	}
catch(...)
{
 
}
}

Cela permets peut être de passer plus d'une propriété - 'property_name' dans mon exemple - (et plus d'une valeur a affecter) a la fonction et d'agir sur des composants possédant a la fois "Text" et "Caption", comme le TLabeledEdit.

Juste pour rire : ca fait une heure que je tourne en rond pour rien -> j'écrivais TPropList au lieu de TPropInfo ...

Tous commentaires/correction bien venus ...

++

[pottiez]

Bonjour,
quelques nouvelles,
j'ai presque réussi à faire ce que je voulais, il me reste le problème que les propriété ne sont pas toujours des String, mais peuvent être des TStringList, comme les Items, je voulais donc passer par la fonction SetPropByName, mais je ne sais pas comment la mettre en œuvre a partir d'un TControl ou d'un TComponent

[Sunchaser]

Bonsoir,

Dans un premier temps, on peut imaginer rajouter un paramètre a la fonction -> un pointeur sur l'objet sur lequel on est en train de travailler. (ici TStringList *taListe par ex)
Le deuxième paramètre reste une chaîne vide lorsque l'on est pas sur un descendant direct de TControl, et l'on appelle pas ainsi le dynamic_cast et la méthode FindComponent( nom de l'objet ).

TObject est supporté a priori par GetPropList(...), donc on pourrait continuer.
Reste a trouver pour l'exacte propriété a cibler dans ces cas la ...

[Sunchaser]

Bonjour,

Au fait, si tu as une TStringList alors ce ne me semble pas forcement judicieux de passer par SetPropByNameet cie ... il te faut juste travailler - par ex - avec un pointeur sur cet objet, dérouler la liste (a moins d'avoir directement l'index ou de pouvoir faire qqchose comme 'IndexOf(...)') et de modifier l'Item, non ?

++

[pottiez]

Bonjour,
Et bien, en fait, d'un côté j'ai mon TStringList, qui provient de mon fichier xml, mais de l'autre, je n'ai qu'un TComponent*, qui lui n'as pas de propriété Items, et cette propriété n'est apparemment pas dans une classe commune à tous les objets qui la contienne

Donc je ne pense pas pouvoir déroulé la liste (si j'ai bien compris par ce que tu entendais par dérouler la liste )

[Sunchaser]

Sorry pottiez,

Je dois avouer que j'ai du mal a me représenter ce que tu obtiens dans ton fichier XML, et ce que l'on doit obtenir en sortie (je suis surement pénible, mais ca doit être l'âge ;-) ).
Dans le cas d'objets simples, ca me paraissait clair: un objet, une propriété, une valeur (grosso modo, je schématise) donc par ex un TEdit, Text, 'blabla'.
Pour le cas du TStringList, et/ou de listes en général, qu'est ce que te donnes ton fichier XML comme info ? Que tu dois travailler sur un TStringList, ok; mais au niveau des 'items', a quoi as tu accès et comment sont ils représentés ?
Tu a le nombre ? les valeurs ? la manière dont ils sont 'indexés' ? ...

Bon courage,
@+