• Ven 15/06/2012

Messages

La gestion de drag-and-drop de fichiers pour en créer des Raccourcis se base sur l'interception d'un message WM_DROPFILES.

Avant de porter de code qui s'occupe de cela de l'ancien outil Raccourci vers le nouveau Gestionnaire de commandes, la gestion des messages Windows par The X-Tools 4 est en train d'être revue. Ce sera désormais le Noyau qui sera responsable de l'interception des deux types de messages entrants :

Les TMessages envoyé par Windows.
Les TMsgs envoyés par le Shell (le bureau).

Chaque type de message étant différent, il y a donc deux méthodes d'instance sur la fenêtre du Noyau :

Code : Tout sélectionner

	// Gestion des messages
	Application.OnMessage := Self.Form_OnTMsg;
	Self.WindowProc := Self.Form_OnTMessage;		// Dérivation de "WndProc"

Ce petit contretemps est nécessaire, car la gestion des messages Windows dans XT3 était un peu artisanale.

Fichiers URL

Un fichier URL est généralement créé de deux manières :

Ajout de la page en cours comme Favori Internet dans un navigateur.
Drag-and-drop d'une adresse ou d'un lien du navigateur vers le bureau.

Contrairement à un lien vers un programme (fichier '.LNK'), un fichier '.URL' est extrèmement simple puisqu'il s'agit d'un banal fichier texte :

URL.png

Dans XT3, les fichiers '.URL' étaient considérés comme des fichiers classiques, donc les Raccourcis créés pointaient vers ces fichiers. La suppression du fichier '.URL' rendait donc le Raccourci inopérant.

Dans XT4, l'adresse pointée par un fichier '.URL' en sera extraite et c'est elle qui sera stockée dans le Raccourci :

Code : Tout sélectionner

//------------------------------------------------------------------------------
// XT400 / XSF_GetURLAddress - Extrait l'adresse d'un fichier '.URL'
//------------------------------------------------------------------------------
function XSF_GetURLAddress(URLFile_Name: String): String;
var
	URLFile: TIniFile;
begin
	// Vérification
	if	FileExists(URLFile_Name)
	then	begin
		// Ouverture du fichier
		URLFile := TIniFile.Create(URLFile_Name);

		// Tentative de lecture de l'adresse
		try	Result := URLFile.ReadString('InternetShortcut', 'URL', '') ;
		except	Result := '';
		end;

		// Fermeture du fichier
		URLFile.Free;
		end;
end;

L'extraction de la cible des raccourcis vers les fichiers ou dossiers (fichiers '.LNK') est déjà fonctionnelle dans XT3.

Fonctions et procédures

En Delphi on distingue :

Les procédures : du code qu'on appelle (avec ou sans paramètres), qui fait quelque chose, mais ne renvoit rien.
Les fonctions : du code qu'on appelle (avec ou sans paramètres), qui fait quelque chose, et qui renvoie le résultat.

Dans certains cas on souhaite qu'une fonction unique puisse renvoyer plusieurs valeurs, afin de factoriser un code complexe ou qui déclenche un traitement long. On peut alors :

Utiliser des variables globales : pas recommandé.
Utiliser une liste : assez lourd, une liste étant en Delphi un objet qu'il faut crééer avant utilisation et supprimer après.
Multiplier les appels, soit à une seule fonction avec un paramètre supplémentaire, soit en décomposant la fonction.

Jusqu'à présent, j'utilisais la troisième méthode. Par exemple en ajoutant un paramètre (prédicat) :

Code : Tout sélectionner

Date := Get('Date', Today);
Month := Get('Month', Today);
Year := Get('Year', Today);

ou en splittant en plusieurs services :

Code : Tout sélectionner

Date := GetDate(Today);
Month := GetMonth(Today);
Year := GetYear(Today);

Je viens de décrouvrir une autre possibilité (assez discrètement documentée) : la spécification de variables en 'out' pour une procédure. Ce qui permet un seul appel comme ceci :

Code : Tout sélectionner

Get(Today, out: Date, Month, Year);

Ce qui a permis la réécriture d'un service unique pour extraire la cible, les paramètres, le fichier d'icône et l'index d'icône d'un fichier lien ('.LNK') :

Code : Tout sélectionner

//------------------------------------------------------------------------------
// XT400 / XSF_GetLinkData - Extrait les données d'un Link
//------------------------------------------------------------------------------
procedure XSF_GetLinkData(Link_File: String; out Link_Target, Link_Parameter, Link_IconFile: String; Link_IconIndex: Integer);
var
	Shell_Link: IShellLink;
	File_Data: TWin32FindData;
	Target_Buffer: Array[0..255] of Char;
	Parameter_Buffer: Array[0..255] of Char;
	IconFile_Buffer: Array[0..255] of Char;
begin
	// Chargement du Link
	Shell_Link := CreateComObject(CLSID_ShellLink) as IShellLink;
	(Shell_Link as IPersistFile).Load(PWChar(WideString(Link_File)), 0);

	// Récupération des données
	Shell_Link.GetPath(@Target_Buffer, SizeOf(Target_Buffer), File_Data, $0002);
	Shell_Link.GetArguments(@Parameter_Buffer, SizeOf(Parameter_Buffer));
	Shell_Link.GetIconLocation(@IconFile_Buffer, SizeOf(IconFile_Buffer), Link_IconIndex);

	// Conversion des données en chaines
	Link_Target := String(Target_Buffer);
	Link_Parameter := String(Parameter_Buffer);
	Link_IconFile := String(IconFile_Buffer);
end;

XMo a écrit : Je viens de décrouvrir une autre possibilité (assez discrètement documentée) : la spécification de variables en 'out' pour une procédure. Ce qui permet un seul appel comme ceci :
Code : Tout sélectionner
Get(Today, out: Date, Month, Year);

Oui, cela se rapproche du passage de variable par référence, qui te permet déjà de modifier plusieurs paramètres dans une procédure, avec l'utilisation du mot-clé "var" devant tes variables.

DMo a écrit :
XMo a écrit : Je viens de décrouvrir une autre possibilité (assez discrètement documentée) : la spécification de variables en 'out' pour une procédure. Ce qui permet un seul appel comme ceci :
Code : Tout sélectionner
Get(Today, out: Date, Month, Year);
Oui, cela se rapproche du passage de variable par référence, qui te permet déjà de modifier plusieurs paramètres dans une procédure, avec l'utilisation du mot-clé "var" devant tes variables.

Yes ils en parlent ici, mais je n'arrive pas à trouver de cas concret où ça puisse être utile. Si c'est une variable globale, pas besoin de la passer en paramètre, si elle est locale, pas vraiment besoin de la modifier via ce paramètre d'entrée/sortie, on peut le faire via "Value := Function(Value)" si on veut.

Raccourcis

Le drag-and-drop à partir de Windows vers le Gestionnaire de commandes permet maintenant de créer des Raccourcis vers des fichiers, dossiers, ou adresses Web :

DropShorcuts.png

Il y a encore un problème avec les icônes extraites des raccourcis dont le passage en 24 bits se fait mal : les pixels partiellement transparents sont noirs.

Menu.png

La solution utilisée pour les images a été de forcer le mode 24 bits comme cela :

Code : Tout sélectionner

	// Création de l'image
	Button_Image := TBitmap.Create;
	Button_Image.PixelFormat := pf24Bit;

Dans le cas des menus, ce sont des icônes, et cette propriété n'existe pas, il va donc sans doute falloir jouer à convertir tout cela : "Icône 32 bits -> Image 32 bits -> Image 24 bits -> Icône 24 bits".

Finalement...

je n'ai pas réussi à faire la conversion souhaitée TIcon -> TBitmap. Une affectation directe explose, et aucune des méthodes trouvées sur Internet n'a fonctionné.

Solution de repli : passer la propriété BkColor de la liste d'images de clNone à clWhite :

BKColor.png

Résultat évidemmment parfait sur fond blanc :

Woooooot.png

Et l'ombre incorrectement "blanchie" est indécelable sur le menu gris clair :

Menu.png

La liste d'image étant désormais unique pour toute l'application, j'espère ne plus jamais avoir affaire à ce problème.

Ven 15/06/2012 - Actualités

Ven 15/06/2012 - Actualités

Ven 15/06/2012 - Actualités

Ven 15/06/2012 - Actualités

Ven 15/06/2012 - Actualités

Re: Ven 15/06/2012 - Actualités

Re: Ven 15/06/2012 - Actualités

Ven 15/06/2012 - Actualités

Ven 15/06/2012 - Actualités