Associer une application à un type de fichier (par son extension)...

Télécharger le projet
Commenter

Description

Ce code contient une application GUI et une application console permettant d'associer un type de fichier à une application, de modifier une association

Pour l'application GUI, lire quand même le fichier Lisez-moi.txt situé dans Assoc (ou le texte ci-dessous).
Ce projet ne permet pas de voir l'association avant de la modifier...

Pour l'application Console :
Impératif : les guillemets entre les guillemets des chaines avec espace (comme "Program Files") doivent être doublés
comme ' en Delphi, " en VB, \ en C...

Les options de la ligne de commande sont :
/EXT:.ext : indique l'extension de l'association de fichier (par ex : ".txt"). Obligatoire.

/PROG:"Nom du programme" : indique le nom du programme qui gère le type de fichier (par ex: "Mon type de fichier"). Facultatif.
/DESC:"Description" : description du type de fichier. Facultatif.
/ID:ProgID : identifiant de programme pour l'extension (par ex: MyApp.Document). Facultatif. Si cette option est omise, un ProgID sera générer si l'association n'existe pas déjà
/ICON:"dll ou exe,index" : fichier exe ou dll (plus index dans les resource) de l'icone à afficher pour ce type de fichier (par ex: "shell32.dll,10"). Facultatif.

/ACTIONNAME:action : nom de l'action à ajouter (par ex : open). Facultatif.
/ACTIONTITLE:titre : titre de l'acion tel qu'il devra être affiché dans la menu déroulant du clic droit sur un fichier de ce type. (par ex : "Ouvrir") Facultatif.
/DEFAULT:action : nom de l'action par défaut (double-clic). Facultatif.
/COMMAND:"commande" : fichier executable à lancer pour faire l'action demandée (par ex : """C:\azerty.exe"" %1"). Facultatif.

/DDECOMMAND:commandedde : commande DDE à envoyer à l'application pour l'action demandée (par ex: "[open(""%1"")]". Facultatif.
/DDEAPPLI:application : nom de l'application qui doit recevoir les messages DDE (par ex: "Azerty"). Facultatif.
/DDETOPIC:sujet : sujet de la conversation DDE (souvent "System"). Facultatif.
/DDEIFEXEC : commande à exécuter si l'application ne répond pas. Facultatif.

Source / Exemple : 


//crée ou modifie une association d//extension de fichier
//======================================================
// szFileExtension : extension de l//association (par ex : ".txt")
// szProgName : nom du programme gérant ce type de fichier (par ex : "Mon Programme")
// szFileTypeDescription : description de ce type de fichier (par ex : "Fichier de mon programme")
// szProgID : ProgID du programme (par ex : "MonProgram.1")
// szDefaultIcon : nom de la dll ou exe qui contient l//icone à afficher pour cette extension (par ex : "shell32.dll,54")
//                                si ce paramètre est "", l//extension n//aura pas d//icone particulière
// lEditFlags : paramètre de l//association, constante FTA_xxx (par ex : FTA_AlwaysShowExt Or FTA_NoRecentDocs)
// szActionName : nom de l//action à effectuer (par ex : "Ouvrir" ou "open")
// szActionTitle : nom de l//action tel qu//il sera afficher dans le menu déroulant (par ex : "Ouvrir avec mon programme")
//                                si ce paramètre est "", szActionName sera affiché dans le menu déroulant
// szDefaultAction : nom de l//action par défaut pour le double-clic (par ex : "Ouvrir" ou "open")
// szCommand : commande à exécuter pour faire l//action (par ex : ""c:\monprogramme.exe" %1")
//                            le %1 représente le nom du fichier de l//action
// szDDECommand : commande à envoyer par DDE pour faire l//action (par ex : "[open("%1")]")
// szDDEApplication : nom de l//application pour DDE (peut être identique à szProgName) (par ex : "Mon Programme")
// szDDETopic : catégorie de la commande (par ex : "System")
// szDDEIfExec : commande à exécuter en cas d//inactivité (pas en cours) de l//application (par ex : "[open("%1)]")
//renvoie ERROR_SUCCESS ou un autre code d//erreur
function FileAssociation(szFileExtension,
                         szProgName,
                         szFileTypeDescription,
                         szProgID,
                         szDefaultIcon: String;
                         lEditFlags: LongWord;
                         szActionName,
                         szActionTitle,
                         szDefaultAction,
                         szCommand,
                         szDDECommand,
                         szDDEApplication,
                         szDDETopic,
                         szDDEIfExec: String
                         ): Boolean;
var
  ret : Cardinal;                 //contient le code d//erreur des appels APIs
  lphKey : HKEY;              //contient le handle de la sous-clé szFileExtension puis szProgID
  lphKeyShell : HKEY;         //contient le handle de la sous-clé "shell"
  lphKeyDefaultIcon : HKEY;   //contient le handle de la sous-clé szDefaultIcon
  lphKeyAction : HKEY;        //contient le handle de la sous-clé szActionName
  lphKeyCommand : HKEY;       //contient le handle de la sous-clé "command"
  lphKeyDDEExec : HKEY;       //contient le handle de la sous-clé "ddeexec"
  lphKeySubDDE : HKEY;        //contient le handle des sous-clés de ddeexec
  cbValue : Integer;
  lphKeyExt: HKEY;
begin
  if Length(szFileExtension) = 0 then
  begin
    Result := False;
    Exit;
  end;

  //on crée une sous-clé dans HKEY_CLASSES_ROOT pour l//extension du fichier
  ret := RegCreateKey(HKEY_CLASSES_ROOT, PChar(szFileExtension), lphKey);

  //si l//on veut seulement modifier une association
  If Length(szProgID) > 0 Then
    //on affecte à la valeur par défaut, le ProgID du programme gérant ce type de fichier
    ret := RegSetValue(lphKey, nil, REG_SZ, PChar(szProgID), 0)
  Else
  begin
    //on alloue de la mémoire pour le ProgID
    SetLength(szProgID,255);
    //on indique la taille allouée
    cbValue := 255;
    //on demande la valeur par défaut = le ProgID
    ret := RegQueryValue(lphKey, nil, PChar(szProgID), cbValue);
    //on supprime l//espace inutile
    szProgID := LeftStr(szProgID, cbValue - 1);

    // si le ProgId n'existe pas
    if Length(szProgID) = 0 then
    begin
      // on initialise le générateur pseudo aléatoire
      Randomize;
      // on répéte
      repeat
        // générer un ProgID aléatoire de la forme 'ft00000000' (comme l'explorateur le fait)
        szProgID := 'ft' + Format('%.8d',[Random(10000000)]);
        // on essaie d'ouvrir une clé de ce nom pour voir si elle existe déjà
        RegOpenKey(HKEY_CLASSES_ROOT,PChar(szProgID),lphKeyExt);
        // on ferme la handle renvoyé par précaution
        RegCloseKey(lphKeyExt);
      // tant que la clé généré existe déjà
      until lphKeyExt = 0;
      // on indique la sous clé ProgID pour l'extension
      ret := RegSetValue(lphKey, nil, REG_SZ, PChar(szProgID), 0)
    end;
  end;
  //on ferme cette clé
  ret := RegCloseKey(lphKey);

  //on crée une sous-clé pour le ProgID
  ret := RegCreateKey(HKEY_CLASSES_ROOT, PChar(szProgID), lphKey);
  If Length(szFileTypeDescription) > 0 Then
    //on affecte à la valeur par défaut, la description de ce type de fichier
    ret := RegSetValue(lphKey, nil, REG_SZ, PChar(szFileTypeDescription), 0);

  //si on a spécifié des paramètres pour ce type de fichier
  If lEditFlags <> 0 Then
    //on les met dans une valeur binaire "EditFlags"
    ret := RegSetValue(lphKey, PChar('EditFlags'), REG_BINARY, PChar(lEditFlags), 0);

  //si on a spécifié une icone pour ce type de fichier
  If Length(szDefaultIcon) > 0 Then
  begin
    //on ajoute une sous-clé "DefaultIcon"
    ret := RegCreateKey(lphKey, PChar('DefaultIcon'), lphKeyDefaultIcon);
    //on affecte à la valeur par défaut le nom de l//icone
    ret := RegSetValue(lphKeyDefaultIcon, nil, REG_SZ, PChar(szDefaultIcon), 0);
    //on ferme cette clé
    RegCloseKey(lphKeyDefaultIcon);
  end;

  //si on a spécifié une action
  If Length(szActionName) > 0 Then
  begin
    //on crée une sous-clé "shell"
    ret := RegCreateKey(lphKey, 'shell', lphKeyShell);
    //si on a spécifié une action par défaut
    If Length(szDefaultAction) > 0 Then
        //on affecte le nom de cette action à la valeur par défaut
        ret := RegSetValue(lphKeyShell, nil, REG_SZ, PChar(szDefaultAction), 0);

    //on crée une sous-clé du nom de l//action dans "shell"
    ret := RegCreateKey(lphKeyShell, PChar(szActionName), lphKeyAction);
    //si elle a un titre
    If Length(szActionTitle) > 0 Then
        //on l//affecte dans la valeur par défaut
        ret := RegSetValue(lphKeyAction, nil, REG_SZ, PChar(szActionTitle), 0);

    //si elle a une commande
    If Length(szCommand) > 0 Then
    begin
        //on crée une sous-clé "command" à shell\<nom de l//action>
        ret := RegCreateKey(lphKeyAction, PChar('command'), lphKeyCommand);
        //on affecte à sa valeur par défaut la commande
        ret := RegSetValue(lphKeyCommand, nil, REG_SZ, PChar(szCommand), 0);
        //on ferme cette sous-clé
        RegCloseKey(lphKeyCommand);
    end;

    //si cette action est gérée par DDE
    If Length(szDDECommand) > 0 Then
    begin
        //on crée une sous-clé "ddeexec" à shell\<nom de l//action>
        ret := RegCreateKey(lphKeyAction, PChar('ddeexec'), lphKeyDDEExec);
        //on affecte à la valeur par défaut, la commande DDE à envoyer pour l//action
        ret := RegSetValue(lphKeyDDEExec, nil, REG_SZ, PChar(szDDECommand), 0);
        //si cela nécessite un nom d//application
        If Length(szDDEApplication) > 0 Then
        begin
            //on crée une sous-clé "Application"
            ret := RegCreateKey(lphKeyDDEExec, PChar('Application'), lphKeySubDDE);
            //et on affecte le nom de l//application à la valeur par défaut
            ret := RegSetValue(lphKeySubDDE, nil, REG_SZ, PChar(szDDEApplication), 0);
            //on ferme la sous-clé "Application"
            RegCloseKey(lphKeySubDDE);
        end;

        //si cela nécessite une catégorie
        If Length(szDDETopic) > 0 Then
        begin
            //on crée une sous-clé "Topic"
            ret := RegCreateKey(lphKeyDDEExec, PChar('Topic'), lphKeySubDDE);
            // et on affecte la catégorie à la valeur par défaut
            ret := RegSetValue(lphKeySubDDE, nil, REG_SZ, PChar(szDDETopic), 0);
            //on ferme cette sous-clé
            RegCloseKey(lphKeySubDDE);
        end;
        //si cela nécessite une commande en cas d//inactivité
        If Length(szDDEIfExec) > 0 Then
        begin
            //on crée une sous-clé "ifexec"
            ret := RegCreateKey(lphKeyDDEExec, PChar('ifexec'), lphKeySubDDE);
            //et on affecte cette commande à la valeur par défaut
            ret := RegSetValue(lphKeySubDDE, nil, REG_SZ, PChar(szDDEIfExec), 0);
            //on ferme cette sous-clé
            RegCloseKey(lphKeySubDDE);
        end;
        //on ferme la clé "ddeexec"
        RegCloseKey(lphKeyDDEExec);
    end;
    //on ferme la sous-clé de l//action
    RegCloseKey(lphKeyAction);
    //on ferme la sous-clé "shell"
    RegCloseKey(lphKeyShell);
  end;

  //on ferme la sous-clé ProgId et on renvoie l//état de l//opération
  Result := (RegCloseKey(lphKey) = ERROR_SUCCESS)
end;

Conclusion :


reprise d'un de mes code VB...

Testé avec Delphi 6

N'hésitez pas à commenté et à noter...
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (ShareVB)