Upxhelper v1.1.1

Soyez le premier à donner votre avis sur cette source.

Vue 4 455 fois - Téléchargée 619 fois

Description

Une interface graphique pour le compresseur d'exécutables UPX téléchargeable ici : http://upx.sourceforge.net/#download
Pratique pour les applications portables sur clé USB.
Rien de particulier dans le source sinon que je découvre la commande ShellExecute et que je joue avec les conditions if, else, then, else if.
Classé chez moi comme micro-projet car ce n'est pas un source énorme.

Merci à Michel34, je me suis inspiré de son source THorloge pour la gestion du fichier .ini

Source / Exemple :


{===============================================================================
Code Source : BEAUMONT Christophe
Version     : 1.1.1
Date        : 07 Mars 2010

Micro Projet 02 - Un programme qui offre une interface utilisateur au compresseur
de programmes UPX, pratique pour les applications portables sur clé USB. Il en
existe un tas mais c'est toujours plus sympa quand c'est fait "maison".
Ne pas oublier de déclarer "ShellAPI" dans les "Uses" pour l'utilisation de
ShellExecute ainsi que 'IniFiles' pour la gestion du fichier de configuration.
===============================================================================}
unit f_main;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ShellAPI, XPMan, ComCtrls, IniFiles;

type
  TUPXHelp = class(TForm)
    LoaderString: TEdit;
    BtnDialog: TButton;
    OpenExe: TOpenDialog;
    XPLook: TXPManifest;
    BtnCompress: TButton;
    BtnDecompress: TButton;
    CompressionBox: TGroupBox;
    CompressionBar: TTrackBar;
    LabTauxCompression: TLabel;
    BruteBox: TCheckBox;
    UBruteBox: TCheckBox;
    OptionsBox: TGroupBox;
    RessourcesBox: TCheckBox;
    ExportsBox: TCheckBox;
    IconesBox: TComboBox;
    RelocsBox: TCheckBox;
    DiversBox: TGroupBox;
    CompatibiliteBox: TCheckBox;
    ForceBox: TCheckBox;
    BackupBox: TCheckBox;
    procedure BtnDialogClick(Sender: TObject);
    procedure CompressionBarChange(Sender: TObject);
    procedure BruteBoxClick(Sender: TObject);
    procedure UBruteBoxClick(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure BtnDecompressClick(Sender: TObject);
    procedure BtnCompressClick(Sender: TObject);
    procedure FormActivate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;

var
  UPXHelp: TUPXHelp;
  UPXPath, INIPath, Parameters : String;
implementation

{$R *.dfm}

procedure TUPXHelp.BtnCompressClick(Sender: TObject);
begin
// On vide le string
 Parameters := '';

 //=============================================================================
 // Ici on commence à traiter les options de compression
 //=============================================================================
// Si "Ultra-Brute" est sélectionné
 if UBruteBox.Checked
 // alors on le déclare en paramètres
   then Parameters := Parameters+' --ultra-brute'
// Sinon on teste "Brute"
   else if BruteBox.Checked
// Si "Brute est sélectionné alors on le déclare en paramètres
        then Parameters := Parameters+' --brute'
// Si aucun des deux n'est coché, on va déclarer le taux de compression
// Si le taux de compression = 10
        else if CompressionBar.Position = 10
// alors on déclare --best en paramètres
            then Parameters := Parameters+' --best'
// Sinon la valeur du taux de compression ( 1 à 9 )
            else Parameters := Parameters+' -'+IntToStr(CompressionBar.Position);

//=============================================================================
// Ici on continue en traitant les options avancées
//=============================================================================
// Si la compression des ressources est sélectionnée
if RessourcesBox.Checked
// alors on valide le paramètre
  then Parameters := Parameters+' --compress-resources=1'
// autrement pas de compression des ressources
  else Parameters := Parameters+' --compress-resources=0';

// Si la compression des exports est sélectionnée
if ExportsBox.Checked
// alors on valide le paramètre
  then Parameters := Parameters+' --compress-exports=1'
// autrement pas de compression des exports
  else Parameters := Parameters+' --compress-exports=0';

// Si l'enlèvement des relocations est sélectionné
if RelocsBox.Checked
// alors on valide le paramètre
  then Parameters := Parameters+' --strip-relocs=1'
// autrement pas d'enlèvement des exports
  else Parameters := Parameters+' --strip-relocs=0';

// On choisit le mode de compression des icônes contenus dans le programme
 Parameters := Parameters+' --compress-icons='+IntToStr(IconesBox.ItemIndex);

//==============================================================================
// Et enfin les options diverses
//==============================================================================
// On vérifie si la compatibilté 8086 est sélectionnée
if CompatibiliteBox.Checked
// Si oui, on ajoute le paramètre
  then Parameters := Parameters+' --8086';
// Doit on forcer la compression ?
if ForceBox.Checked
// Si oui alors on ajoute le paramètre
  then Parameters := Parameters+' --force';
// Et enfin, doit on faire une sauvegarde du programme avant traitement ?
if BackupBox.Checked
// Si oui, on ajoute le paramètre pour une sauvegarde
  then Parameters := Parameters+' --backup'
// Si non, on ne fait pas de sauvegarde du programme et on l'écrase
  else Parameters := Parameters+' --no-backup';

  // Et enfin on exécute upx.exe et son armada de paramètres
 ShellExecute(GetDesktopWindow, 'open', PChar(UPXPath), PChar('"'+UPXPath+'"'+Parameters+' '+'"'+LoaderString.Text+'"'), nil, SW_SHOWNORMAL);
end;

procedure TUPXHelp.BtnDecompressClick(Sender: TObject);
begin
// On passe en paramètres la commande pour décompresser
 Parameters := ' -d';
// Si on a choisit de faire une sauvegarde du fichier compressé
 if BackupBox.Checked then
  begin
// on indique la sauvegarde en paramètres
   Parameters := Parameters+' --backup';
  end
  else
// Autrement pas de sauvegarde
  Parameters := Parameters+' --no-backup';
// Et on exécute upx.exe avec sa ligne de commande en paramètres et le programme cible
  ShellExecute(GetDesktopWindow, 'open', PChar(UPXPath), PChar('"'+UPXPath+'"'+Parameters+' '+'"'+LoaderString.Text+'"'), nil, SW_SHOWNORMAL);
end;

procedure TUPXHelp.BtnDialogClick(Sender: TObject);
begin
// Renvoie true lorsque l'utilisateur effectue une sélection et clique sur OK, et renvoie
// false lorsque l'utilisateur ferme la boîte de dialogue sans effectuer de sélection.
 if OpenExe.Execute then
  begin
// On affiche le chemin et le nom du programme sélectionné
    LoaderString.Text := OpenExe.FileName;
// On active les boutons "Compresser" et "Décompresser" qui étaient désactivés pour éviter
// de gérer une erreur de fichier non sélectionné.
    BtnCompress.Enabled := True;
    BtnDecompress.Enabled := True;
  end;
end;

procedure TUPXHelp.BruteBoxClick(Sender: TObject);
begin
// Si l'option "Brute" est sélectionnée
 if BruteBox.Checked  then
// alors on déselectionne "Ultra Brute"
  UBruteBox.Checked := False;
end;

procedure TUPXHelp.UBruteBoxClick(Sender: TObject);
begin
// Si l'option "Ultra Brute" est sélectionnée
 if UBruteBox.Checked  then
// alors on déselectionne "Brute"
  BruteBox.Checked := False;
end;

procedure TUPXHelp.CompressionBarChange(Sender: TObject);
begin
// On affiche le taux de compression ( 1 à 10 )
 LabTauxCompression.Caption := IntToStr(CompressionBar.Position);
end;

procedure TUPXHelp.FormActivate(Sender: TObject);
var INI : TIniFile;
begin
// Create construit un objet TCustomIniFile pour une application et affecte le paramètre FileName
// à la propriété FileName pour spécifier le nom du fichier ini à utiliser
 INI := TIniFile.Create(INIPath+'UPXHelper.ini');

 // On charge une chaîne de caractères (string)
 LoaderString.Text := INI.ReadString('Options','LastFile','');
 // On charge la valeur du taux de compression (Integer), valeur par défaut = 7
 CompressionBar.Position := INI.ReadInteger('Options','Compression',7);
 // On charge l'état du composant (True ou False), valeur par défaut = False
 BruteBox.Checked := INI.ReadBool('Options','Brute',False);
 UBruteBox.Checked := INI.ReadBool('Options','UBrute',False);
 // On charge l'état du composant (True ou False), valeur par défaut = True
 RessourcesBox.Checked := INI.ReadBool('Options','Ressources',True);
 ExportsBox.Checked := INI.ReadBool('Options','Exports',True);
 RelocsBox.Checked := INI.ReadBool('Options','Relocations',True);
 IconesBox.ItemIndex := INI.ReadInteger('Options','Icones',2);
 CompatibiliteBox.Checked := INI.ReadBool('Options','Compatibilite',False);
 ForceBox.Checked := INI.ReadBool('Options','Force',False);
 BackupBox.Checked := INI.ReadBool('Options','Backup',False);

 // On libère le fichier .ini
 INI.Free;
// On n'oublie pas d'activer nos boutons si nous avons un programme déclaré
 if LoaderString.Text <>'' then
   begin
    BtnCompress.Enabled := True;
    BtnDecompress.Enabled := True;
   end
end;

procedure TUPXHelp.FormCreate(Sender: TObject);
begin
// Récupère le chemin d'accés à notre programme
 INIPath := ExtractFilePath(Application.ExeName);
 // et ajoute upx.exe
 UPXPath := INIPath+'upx.exe';
 // Si upx.exe n'est pas dans le répertoire de notre programme
 if not FileExists(UPXPath) then
// On affiche un avertissement.
  ShowMessage('Upx.exe est absent du répertoire');
end;

procedure TUPXHelp.FormDestroy(Sender: TObject);
var INI : TIniFile;
begin
// Créé le fichier Ini s'il n'existe pas, on définit aussi le répertoire courant
// comme chemin sinon le fichier se créé dans le répertoire Windows
 INI := TIniFile.Create(INIPath+'UPXHelper.ini');

// On va écrire le dernier programme sélectionné ainsi que son chemin d'accès (string)
 INI.WriteString('Options','LastFile',LoaderString.Text);
// La valeur du taux de compression de 1 à 10 (Integer)
 INI.WriteInteger('Options','Compression',CompressionBar.Position);
// La valeur boléenne du composant (True ou False)
 INI.WriteBool('Options','Brute',BruteBox.Checked);
 INI.WriteBool('Options','UBrute',UBruteBox.Checked);
 INI.WriteBool('Options','Ressources',RessourcesBox.Checked);
 INI.WriteBool('Options','Exports',ExportsBox.Checked);
 INI.WriteBool('Options','Relocations',RelocsBox.Checked);
 INI.WriteInteger('Options','Icones',IconesBox.ItemIndex);
 INI.WriteBool('Options','Compatibilite',CompatibiliteBox.Checked);
 INI.WriteBool('Options','Force',ForceBox.Checked);
 INI.WriteBool('Options','Backup',BackupBox.Checked);

// On libère le fichier .ini
 INI.Free;
end;

end.

Conclusion :


J'ai enfin bien compris l'utilisation des conditions ;)

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Messages postés
80
Date d'inscription
lundi 2 juin 2003
Statut
Membre
Dernière intervention
15 juin 2012

Photoshop CS4 portable c'est déjà 1,8Go, sans compter les autres que j'utilise très fréquemment autant qu'en graphisme qu'en développement de sites. c'est simple ma clé 16Go est quasi complète.As tu déjà créé un journal au format Publisher en très haute qualité ? Certains fichiers font plus de 100Mo en qualité pour l'imprimerie. Cà va donc très vite quand tu sors un hebdo de 16 pages! Je n'ai aucun problème de mémoire et aucun swapp disque mais par contre si je peux gratter 20Mo par ci ou par là et bien là je suis content car çà m'est plus utile. Chacun voit midi à sa porte selon ses besoins.
DelphiProg a dit : "Il y avait longtemps qu'on n'avait pas parlé d'UPX" donc j'imagine que ce débat a déjà eut lieu donc je vais stopper là.

Salutations.
Messages postés
991
Date d'inscription
samedi 25 octobre 2003
Statut
Membre
Dernière intervention
29 août 2013
5
Désolé d'avance pour le commentaire qui n'est peut-être pas constructif (je n'ai pas regardé la source, juste les commentaires).
"Il est loin le temps de mon amiga et de ses 512Ko, mon PC HP vieux de 2 ans à 4Go ainsi que mon portable(...)"
A ceci je dirais qu'il est loin le temps des clés USB de 12Mo; c'est difficile aujourd'hui de trouver des clés < 1Go. Donc je trouve le commentaire de Julio pertinent car, si on utilise cette technique pour compresser une exe de taille consequente, on perd toute l'utilité du chargement partiel de l'exécutable qui prend tout son sens sur des applications de cette taille.
Messages postés
23
Date d'inscription
vendredi 3 janvier 2003
Statut
Membre
Dernière intervention
27 juin 2011

En tout cas c'est encore une fois très bien commenté, les expliquations sont claires donc que dire .... allez christophe67 un ptit code par jours !!! et l'amiga c'était quand même une sacré bécane !!!
Messages postés
80
Date d'inscription
lundi 2 juin 2003
Statut
Membre
Dernière intervention
15 juin 2012

Bonjour JulioDelphi,

C'est un point de vue qui se défend auquel j'opposerai ceci.
Il est loin le temps de mon amiga et de ses 512Ko, mon PC HP vieux de 2 ans à 4Go ainsi que mon portable. Tout çà pour dire que c'est bien souvent la configuration standard proposée alors gagner ou perdre 1mo pour lancer un exécutable est à mon avis moins gênant que de gagner plusieurs Mo sur une clé USB sur laquelle se trouve les versions portables de la plupart des logiciels que j'utilise.
Donc "pour moi" ce programme à son utilité.
Quand j'ai démarré la programmation en assembleur sur Amiga on hyper optimisait le moindre octet gagné ainsi que le moindre cycle processeur, quand on voit qu'un simple "Hello world" sur une fiche de Delphi prend 700Ko on est loin de l'esprit de tout optimiser.

Salutations.
Messages postés
2226
Date d'inscription
dimanche 5 octobre 2003
Statut
Modérateur
Dernière intervention
18 novembre 2010
13
Bonjour voici un mot sur les compresseurs d'executables (UPX ici).
(source : Delphi 7 Studio)
"
Puisque nous parlons de réduction de taille de code, il semble à propos de glisser un mot sur ces logiciels qui se proposent de compresser les exécutables, voire les DLL, pour gagner de la place. Ne succombez pas à l'appel de ces sirènes et de leur chant trompeur : si ces programmes vous donneront l'impression que l'exécutable est effectivement plus petit sur le disque, a contrario il prendra énormément plus de place en mémoire une fois chargé ! A cela une bonne raison : Windows sais gérer les différents blocs d'un exécutable et ne charge en mémoire que ce qui est utile. Par exemple, une application contenant 200 fiches et qui prendrait 15 mo sur le disque et dont seulement 1 ou 2 fiches sont crééés à la fois ne prendra que très peu de place en mémoire... En compressant l'exécutable, les logiciels évoqués (UPX) ici transforment la quasi-totalité du fichier EXE en un seul bloc de données précédé d'un chargeur (la partie qui décompresse et passe le contrôle au code décompressé en mémoire). De fait, Windows ne voit qu'un seule bloc logique et charge tout en mémoire. Une application sera donc chargée en totalité en mémoire, ralentira Windows, forcera le swapping et autres nuisances du même genre. La technique de compression d'exécutable ne peut, à la rigueur, être exploitée que sur des applications très petites (1 ou 2 fiches), de type utilitaire par exemple. Mais dans ce cas le gain de place en Mo est négligeable. Au final, rien ne justifie donc d'utiliser de trels programmes de compression ...
"
Afficher les 8 commentaires

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.