Criando Instal Adores para Windows Com o Inno Setup
Criando Instal Adores para Windows Com o Inno Setup
Criando Instal Adores para Windows Com o Inno Setup
o Inno Setup
Introdução
Entre várias outras coisas, o Inno Setup permite criar chaves no registro e em arquivos
INI, além do básico de um instalador: copiar arquivos para alguma pasta e a criação de
atalhos. Ele tem várias propriedades que podem ser configuradas, como limitar a
instalação a somente administradores, registrar DLL/OCX, instalar fontes, e muito mais.
Ainda cria um desinstalador, que pode remover completamente seu programa. Uma
grande possibilidade é que ele tem suporte a uma espécie de "programação" interna,
onde você pode personalizar o instalador usando algumas funções como se estivesse
num ambiente de programação. É possível também chamar funções de DLLs, ou seja:
as possibilidades são imensas.
http://www.jrsoftware.org/
A geração dos instaladores com o Inno Setup se dá por meio de um script. O compilador
dele lê o script e gera um executável, unindo seus arquivos, as configurações e o
módulo do instalador (um executável pronto, que realizará a instalação baseando-se nas
configurações definidas). O resultado é um único arquivo .exe, que pode ser facilmente
distribuído. O instalador dos seus programas terá esta aparência:
A criação do script, que é basicamente um arquivo de texto puro (com a extensão .iss),
pode ser feita digitando-se os comandos manualmente ou então usando o assistente de
criação do Inno - que gera um projeto básico. A forma mais fácil de criar um novo
instalador é usar o assistente, e depois modificar o arquivo do projeto manualmente. E
claro, modificar várias vezes, compilar e testar, até ficar pronto :)
O assistente dele faz o básico, vou me concentrar em mostrar alguns pontos importantes
para um bom instalador, como a criação de chaves no registro, e orientação sobre como
"programar" no Inno Setup, dando exemplo de uso de uma DLL externa.
O assistente do Inno exibe algumas telas, basta você ir preenchendo com as informações
do seu programa e avançando:
Ao final, ele tem um script básico, que você poderá modificar sem grandes dificuldades.
Antes de começar, é bom ter organizado e separado os arquivos do seu programa. Deixe
tudo o que deverá existir no sistema do usuário em uma pasta, com subpastas, se
necessário - toda a estrutura será copiada. Separe também o texto da licença da
aplicação, de preferência num arquivo TXT.
Iniciando o compilador do Inno Setup, escolha a opção "Create a new script using the
Script Wizard". Vá preenchendo as informações conforme solicitadas, e ao concluir,
terá o script padrão gerado. Considerando que ele é um gerador de programas de
instalação para um software que você tenha criado, não haverá dificuldade em passar
pelo assistente. Para compilar seu projeto, tecle CTRL+F9, e para compilar e testar, F9
apenas (como no Delphi). Você pode usar os menus ou botões da barra de ferramentas
também, claro. O ambiente do Inno funciona como um debugger, mostrando quando
algo estiver errado (inclusive indicando a linha), além de exibir um log da instalação em
andamento (enquanto você testar o instalador a partir da interface dele). O arquivo para
ser distribuído será o setup.exe, que por padrão fica na pasta "Output", onde estiver
salvo o script.
[Setup]
; NOTE: The value of AppId uniquely identifies this application.
; Do not use the same AppId value in installers for other applications.
; (To generate a new GUID, click Tools | Generate GUID inside the IDE.)
AppId={{4BD6DFD3-105A-4921-B253-3F15E6022B5C}
AppName=My Program
AppVerName=My Program 1.5
AppPublisher=My Company, Inc.
AppPublisherURL=http://www.example.com/
AppSupportURL=http://www.example.com/
AppUpdatesURL=http://www.example.com/
DefaultDirName={pf}My Program
DefaultGroupName=My Program
OutputBaseFilename=setup
Compression=lzma
SolidCompression=yes
[Languages]
Name: "brazilianportuguese"; MessagesFile:
"compiler:LanguagesBrazilianPortuguese.isl"
[Tasks]
Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}"; GroupDescription:
"{cm:AdditionalIcons}"; Flags: unchecked
[Files]
Source: "C:Program Files (x86)Inno Setup 5ExamplesMyProg.exe"; DestDir: "{app}";
Flags: ignoreversion
; NOTE: Don't use "Flags: ignoreversion" on any shared system files
[Icons]
Name: "{group}My Program"; Filename: "{app}MyProg.exe"
Name: "{commondesktop}My Program"; Filename: "{app}MyProg.exe"; Tasks:
desktopicon
[Run]
Filename: "{app}MyProg.exe"; Description: "{cm:LaunchProgram,My Program}";
Flags: nowait postinstall skipifsilent
Veja que o arquivo tem o estilo dos arquivos INI, sendo bem fácil de editar. Algumas
seções permitem vários parâmetros, neste caso eles devem ser separados por ponto-e-
vírgula, além de terem seu conteúdo declarado entre aspas, se tiver espaços.
[Languages]
O "Default.isl" é o arquvio de texto com as mensagens para inglês, ele está na pasta do
Inno Setup (por isso pode-se usar "compiler:", que retorna a pasta do compilador do
Inno). O Inno Setup gera instaladores multi-linguagem, e caso tenha mais de um idioma
definido, aparecerá uma caixa de diálogo para seleção da linguagem no começo da
instalação.
Das outras seções, a [Files] é a mais importante. Ela define as pastas e arquivos que
serão instalados no sistema. A [Icons] permite a criação de atalhos, a [Run] a execução
de comandos logo após a conclusão da instalação, e a [Tasks] permite criar "tarefas",
itens de checkbox que aparecerão antes de iniciar a instalação, podendo ser marcados ou
desmarcados pelo usuário. As entradas nas outras seções referenciando uma tarefa
previamente definida na seção [Tasks] só serão executadas se o usuário deixar marcada
a opção correspondente, durante a instalação.
O uso do Inno não é difícil, mas você precisa dedicar um tempinho até entender como
as entradas do script dele se relacionam. Na pasta "Examples", dentro da pasta do Inno,
existem exemplos básicos sem muitas entradas - permitindo que você estude um assunto
por vez. Nesse artigo vou destacar alguns meios de usar o Inno para gerar instaladores
mais profissionais e responsáveis, sem ficar usando muito as opções "padrões" apenas.
Particularmente fiz algumas modificações no Inno Setup, e lancei um fork dele com o
nome Mep Installer. Traduzi o programa inteiro e o conteúdo da ajuda (pelo menos dos
recursos que mantive). O material serve como um ótimo tutorial e referência em
português de boa parte dos recursos do Inno Setup, e pode ser lido sem precisar instalar
o programa, em:
http://www.mephost.com/software/help/mpist14/ajuda.htm
• Na desinstalação, limpe tudo o que o seu programa colocar, mas tome o cuidado
de não apagar arquivos do usuário. O Inno Setup remove uma boa parte do que
ele faz na instalação automaticamente. Mas em algumas situações, alguns
arquivos podem permanecer no HD. Tome o cuidado de remover estes arquivos
(comentarei como logo mais).
[Setup]
AppName=Meu Programa
AppPublisher=Meu nome
Outras seções podem possuir mais parâmetros, geralmente separados por um ponto-e-
vírgula. Veja:
[Files]
Não é recomendável especificar duas vezes uma mesma seção, coloque as diretivas ou
parâmetros de uma mesma seção embaixo da mesma identificação dela.
Você pode colocar comentários dentro do script. Comentários são textos que não são
compilados, eles apenas indicam alguma coisa, em especial para quem irá ler ou
trabalhar com o script ("script" é o "texto" do arquivo de projeto). Basta iniciar uma
linha com o ponto-e-vírgula:
Se você possui um arquivo de projeto com informações que deverão se repetir em várias
instalações, pode utilizar a diretiva #include. O conteúdo do arquivo indicado será
inserido no local especificado, e após ele as informações que estiverem serão
continuadas, como se fossem um arquivo só. A sintaxe é:
#include "meuarquivo.iss"
A extensão não precisa ser necessariamente .iss, pode ser outra se você quiser, como
.txt, por exemplo.
O arquivo informado deverá estar na mesma pasta do arquivo de projeto, ou então você
pode informar o caminho completo (por exemplo, "C:Minha pastaMeu arquivo.iss"). Se
o arquivo estiver na mesma pasta do compilador, você pode utilizar assim: #include
compiler:teste.iss. Aliás, "compiler:" será substituído pelo caminho da pasta do
compilador, em diversas seções.
[Files]
Geralmente se utilizam aspas duplas (") para definir o valor de um parâmetro definido
pelo usuário, como por exemplo o nome de um arquivo. Usar aspas quase sempre não é
obrigatório, mas é necessário quando o valor tiver espaços.
Se precisar utilizar aspas duplas em alguma definição, coloque duas aspas duplas
consecutivas, para evitar conflito com as aspas delimitadoras do parâmetro. A linha a
seguir:
Se você quiser que o valor de um parâmetro seja uma única aspa dupla, utilize então
quatro caracteres de aspas duplas: """". Os caracteres das extremidades cercam o valor
como sendo um valor definido pelo usuário, e os dois do meio são para gerar um único
caractere de aspa.
O assistente de criação de script do Inno cria uma entrada para cada arquivo que você
adicionar, na seção [Files]. Por exemplo:
[Files]
Conforme você for tendo muitos arquivos, ou pastas e subpastas, essa idéia pode ficar
confusa. A minha recomendação é criar uma pasta e deixar nela todos os arquivos do
seu programa, incluindo subpastas, exatamente como você quer que eles fiquem na
pasta do seu programa no sistema dos usuários. Assim, a seção [Files] teria uma entrada
só:
[Files]
Tudo o que estiver na pasta "C:programa" será copiado para a pasta da aplicação (seja
ela qual for, dado o uso da constante {app}, que retornará o caminho do seu programa
no sistema dos usuários). Para incluir as subpastas e tudo o que existir dentro delas
também, é necessário adicionar a flag recursesubdirs (note ela no final da linha acima).
Se você precisar copiar arquivos para outros lugares, como a pasta do Windows, por
exemplo, pode deixá-los numa pasta separada (fora da "C:programa", no exemplo) e
incluir uma nova entrada na seção [Files], para o novo arquivo:
DefaultDirName={pf}Meu programa
Para a maioria das instalações, não é necessário alterar esse caminho. O instalador
gravará no registro (na mesma chave de desinstalação) o caminho em que for instalado,
e caso uma nova versão do programa for instalada, ele manterá a pasta existente como
padrão.
Ele detecta se o programa já está instalado ou não com base no valor da diretiva AppId,
ID da aplicação, na seção [Setup]. Quando você fizer uma nova versão do seu
programa, que não puder ser entendida como uma atualização da atual (ou que possa
coexistir com ela no sistema), altere o valor da AppId. Mas não faça isso se você
pretende que o programa seja atualizável, por exemplo, da versão 1.2 para 1.5. É bom
escolher um nome para a AppId que só o seu programa use, e seus programas diferentes
também deverão usar IDs diferentes.
Uma outra recomendação minha é manter o arquivo de projeto numa pasta, e dentro
dessa pasta a pasta com os arquivos do programa a serem inclusos. Exemplo de
estrutura:
instalador.iss
leiame.txt
licença.txt
pasta_de_arquivos_do_programa
Assim, dentro do arquivo .iss você pode referenciar os arquivos usando caminhos
relativos, como por exemplo:
[Files]
Se precisar mover a pasta de lugar, leve tudo junto com ela. Dessa forma você não
precisará editar o arquivo para retirar a referência estática, como C:pasta, por exemplo.
A criação de atalhos pode ser configurada na seção [Icons]. Tem esta sintaxe:
[Icons]
O parâmetro "Name" recebe o caminho do atalho, sem precisar colocar a extensão .lnk.
Por padrão, o Inno Setup cria uma subpasta do menu "Iniciar > Programas". É útil
quando você instala vários atalhos, no mesmo grupo de programa (ou se quiser separar
um grupo de atalhos para a sua empresa, e dentro dela colocar os atalhos dos
programas). Esse caminho pode ser alterado por padrão na diretiva DefaultGroupName,
da seção [Setup].
[Icons]
A criação de chaves no registro durante a instalação pode ser feita com a função
[Registry]. Algumas flags especiais devem ser usadas nas chaves que o seu programa
criar, para que elas possam ser removidas automaticamente na desinstalação. Já nas
chaves públicas ou do Windows, em que o seu programa simplesmente alterar alguns
valores, tenha cuidado: nunca use a flag para remoção na desinstalação.
[Registry]
O parâmetro Root define a chave root do registro que será alterada. Você deve colocar
HKCU para a HKEY_CURRENT_USER, ou HKLM, para a
HKEY_LOCAL_MACHINE (entre outras). No SubKey, defina o caminho desejado.
Ele não precisa existir no sistema. Se não existir, será criado automaticamente. Por
exemplo, "SoftwareMinha EmpresaMeu Programa". Lembre-se de colocar textos que
contenham espaços entre aspas. Em ValueType, defina o tipo do valor, que pode ser
dword (inteiro), string (os mais usados), entre alguns outros. Para valores booleanos,
use dword, e atribua ao valor 1 para True, ou 0 para False. Em ValueData, como era de
se esperar, coloque o dado do valor. Se for uma string, prefira colocar entre aspas. Um
exemplo:
Repare que você pode usar constantes do Inno Setup no valor, se precisar, para usar
caminhos de pastas ou arquivos que variam de sistema para sistema - como no caso,
usei a {app} para retornar a pasta da aplicação, já que queria referenciar um arquivo
dentro dela.
Apesar de não ser necessário seguir a ordem no script do Inno para as chaves do
registro, uma organização sempre faz bem. Por experiências próprias com ele, sugiro
criar as chaves definindo que elas deverão ser removidas após a instalação, e só depois
de declarar isso, colocar as entradas que gravarão os valores propriamente ditos. Por
exemplo:
Seguindo a forma exemplificada nas 4 linhas mais acima, você obtém um instalador
mais "profissional". Ele cria a chave para a empresa, se ainda não existir, e configura
para removê-la na desinstalação apenas se estiver vazia (com o uso da flag
uninsdeletekeyifempty). Após isso, cria a chave do programa, dentro da chave da
empresa, e configura para remoção na desinstalação, mesmo se não estiver vazia (já que
está removendo o programa, não teria porque manter a chave do registro dele). A flag
uninsdeletekey faz com que a chave e todas as suas subchaves sejam removidas na
desinstalação. Caso você tenha vários programas, eles nunca removerão as
configurações dos outros, pois cada um terá sua própria chave, sob o nome da chave da
empresa. Ao desinstalar o último programa desta empresa, é que a chave da empresa
será removida. Antes disso, não, pois com o uso da flag uninsdeletekeyifempty para a
chave da empresa, esta não será excluída se ainda existirem subchaves (provavelmente
de seus outros programas). Uma dica é colocar na ordem exibida. Na desinstalação, o
Inno Setup executa as funções correspondentes de baixo para cima no script, as
primeiras entradas serão as últimas a serem tratadas na desinstalação.
Caso você não queira usar uma chave para a empresa (que pode ser o seu nome, o
produtor do programa), pode então usar diretamente uma para o programa, ficando
assim apenas:
Nunca use o uninsdeletekey em chaves usadas por outros programas ou pelo Windows.
E a definição das chaves que seu programa usará deve ser feita no projeto do programa,
não apenas na hora da criação do instalador. Se seu programa irá criar novas chaves em
outros locais depois de aberto, é uma boa incluí-las para remoção, bastando definir da
forma acima, como se fosse criá-las, e usar as flags uninsdeletekey ou
uninsdeletekeyifempty, dependendo da situação.
[Registry]
Onde:
.myp é a extensão desejada;
My Program File é a descrição dos arquivos desse tipo, que aparecerá no Windows
Explorer;
Como as aspas são usadas internamente pelo Inno, é necessário usá-las duas vezes
seguidas, "", para que sejam gravada no registro uma única aspa.
Ao associar arquivos ao seu programa, tenha em mente que o mesmo deverá estar
programado para abrir arquivos passados como parâmetro pela linha de comando. Caso
contrário, ao dar um duplo clique num arquivo da extensão escolhida, o seu programa
até será aberto, mas sem fazer nada - sem abrir o arquivo.
Lembre-se que você pode consultar a ajuda do Inno Setup (ou a ajuda on line do Mep
Installer, que está em português) para ver as outras opções possíveis.
Comum em muitos programas de instalação, pode ser útil rodar programas no final da
instalação ou antes da desinstalação. Para isso existem as seções [Run] e
[UninstallRun]. A sintaxe básica delas não têm segredo, e compartilham muitas
propriedades. A Run roda programas ao final da instalação, antes de concluí-la, e a
UninstallRun, antes da desinstalação começar.
Um exemplo:
[Run]
São vários os parâmetros, há uma lista na ajuda que comentei, do Mep Installer:
http://www.mephost.com/software/help/mpist14/secao_run.htm
Antes da desinstalação é a mesma coisa, use apenas dentro da [UninstallRun].
Por padrão, o instalador do Inno Setup exclui apenas arquivos que ele tenha criado. Se
seu programa criar pastas ou arquivos depois de instalado, estes permanecerão no
sistema do usuário. Algumas vezes podem ser arquivos INI, que ficam na pasta da
aplicação (inadequado hoje em dia, visto que os usuários limitados não podem gravar
nada na pasta Arquivos de programas, mas muitos "programadores" insistem em usar
isso, em vez de guardar o INI numa pasta sob o perfil do usuário). Seja qual for o caso,
ao desinstalar seu programa a pasta dele poderá permanecer no sistema do usuário - o
que é um tanto "chato" e incômodo.
[UninstallDelete]
Defina files no parâmetro Type para excluir arquivos, e filesandordirs para excluir
arquivos ou pastas (incluindo subpastas e tudo o que existir dentro delas).
Em outras situações, pode ser necessário remover algum arquivo durante a instalação.
Um exemplo é quando uma nova versão do seu programa não usa mais um arquivo que
uma versão anterior usava. Seria bom removê-lo :)
O Inno Setup pode proteger a instalação com uma senha, é uma medida de "segurança"
básica. A senha não é a mesma coisa de um número serial, apesar de ter função
parecida: sem ela, não será possível continuar a instalação. É simples, basta definir a
diretiva Password na seção [Setup]:
Password=teste
A tela que pede a senha para o usuário será assim:
A senha não será gravada no arquivo diretamente, mas sim um hash (sombra) dela. Os
arquivos, o conteúdo do instalador em si, não estarão "protegidos": eles não são
encriptados por padrão. Você pode forçar uma encriptação usando a diretiva
Encryption, ativando-a com "yes" na seção [Setup]:
Password=teste
Encryption=yes
Para isso, uma DLL com a função de criptografia do Inno deverá ser colocada na pasta
do Inno Setup. Ele não inclui o suporte "nativo" à criptografia devido a legislação de
alguns países. Basta baixar a DLL em:
http://www.jrsoftware.org/isdl.php
A proteção por número serial é um recurso possível no Inno Setup, mas não
"diretamente". Com a diretiva UserInfoPage=yes na seção [Setup], ele mostra uma tela
para digitação de um nome de usuário e organização. Mas não um número serial. O
nome e a organização poderão ser recuperados com as constantes {userinfoname} e
{userinfoorg}, podendo ser gravados no registro, num arquivo INI ou então passados
como parâmetro para algum programa (usando a seção [Run], deixando a constante
{userinfoname} ou {userinfoorg} como parâmetro para o seu executável).
Para que apareça o campo de número serial, você deverá usar a seção [Code]. O Inno
Setup, a partir da versão 4, permite a codificação usando o Pascal Script. É uma
linguagem de script baseada em Pascal, muito parecida com o Delphi. Você pode
"programar" dentro do Inno, executar funções personalizadas em algumas situações e
inclusive chamar funções em DLLs - suas ou não.
A seção [Code] é um pouco complexa para entender de imediato, ela contém funções e
rotinas próprias que se aplicam apenas ao Inno Setup, assim como contém funções
comuns a outros ambientes (principalmente ao Delphi; a saber, o Inno Setup é feito em
Delphi). Para verificação de número serial, você deve criar a seção [Code] no script do
Inno, e colocar a função CheckSerial. Esta função tem esta sintaxe:
O que ela faz? Ela recebe o serial preenchido pelo usuário, que é passado como string, e
deve devolver um valor booleano (sim ou não), para liberar ou não a instalação. Para
implementá-la, coloque no final do arquivo de script do Inno Setup:
[Code]
begin
end;
Entre o begin e o end você pode fazer literalmente o que quiser, como se estivesse num
ambiente de programação. As funções internas providas com o Inno Setup são básicas,
mas você poderá chamar DLLs, como explico já já.
begin
if Serial = '123456' then
Result := True
else
Result := False;
end;
Isso limita a instalação ao serial "123456". Experimente compilar o instalador e testar :)
Se você quiser, pode implementar um pouco mais, e testar também o nome de usuário e
a organização preenchidos. Para isso, precisará usar variáveis e a função
ExpandConstant, que expande uma constante do Inno, retornando o valor dela como
string:
var
begin
usu := ExpandConstant('{userinfoname}');
org := ExpandConstant('{userinfoorg}');
if (usu = 'Marcos') and (org = 'Guia do Hardware') and (Serial = '123456') then
Result := True
else
Result := False;
end;
Coloquei assim por motivos didáticos, nada impede que você simplifique a verificação
do if, deixando-o apenas assim:
Result := (usu = 'Marcos') and (org = 'Guia do Hardware') and (Serial = '123456');
Uma observação importante no Inno Setup, é que esta função é chamada para cada
caractere que o usuário digitar. Se você inventar algum algoritmo de verificação
diabólico que coma muito processamento, a digitação do serial pelo usuário ficará
"lenta". Ele chama a função ao digitar, pois libera o botão "Avançar" apenas se a
informação estiver correta. Enquanto a função CheckSerial retornar False, o botão
Avançar fica desativado.
Nada impede que algum "hacker" manipule o estado do botão Next do Inno Setup,
usando aplicações de terceiros, e parta para a próxima tela sem digitar o número serial.
O recurso é interessante, mas deve ser usado com cuidado. O Inno é um projeto aberto,
suas especificações são claras e qualquer um munido de conhecimentos avançados pode
manipular a função CheckSerial para sempre retornar True. A recomendação seria usar
um sistema de registro externo ao Inno, com um algoritmo criado por você, e talvez usar
o campo de serial apenas para a inserção do serial e posterior processamento - algo que
pode ser útil dado o visual do instalador, ficaria mais "tradicional" solicitar o número
serial durante a instalação. Uma proteção maior pode se dar usando a senha com
criptografia ativada, como comentado mais acima - onde mesmo se o "hacker" burlar o
sistema e conseguir avançar, os arquivos estarão altamente corrompidos sem a senha
certa, e não servirão para nada.
Uma das grandes vantagens do Inno Setup é a liberdade de programação. Com o Pascal
Script, você pode usar uma série de funções para fazer uma infinidade de coisas. As
funções inclusas com o Inno constam na ajuda dele, vale a pena dar uma conferida. E
para as que não estão, você pode usar funções de DLLs, sejam estas suas ou não.
O primeiro nome ValidaReg escolhido pode ser um nome qualquer, será o nome da
função importada dentro do programa - dentro do instalador. Ela receberá três
parâmetros: o nome do usuário, organização e número serial preenchidos. E deverá
retornar um valor booleano, True para liberar a instalação, ou False para negá-la.
Na segunda linha, fica indicado que a ValidaReg está na DLL CheckSerial.dll (que
poderia ser qualquer outra). Mas onde estará esta DLL no sistema do usuário?
Você deve incluí-la no instalador, na seção [Files], com a flag especial dontcopy:
[Files]
...
Essa flag faz que o arquivo indicado não seja copiado para a pasta da aplicação. Ele
ficará numa pasta temporária que o Inno Setup cria durante a instalação, e a remove
assim que a instalação é concluída.
Declarada a função da DLL, você pode usá-la no código da seção [Code], como se fosse
uma função nativa do Inno. No caso da verificação do número serial, mudaríamos o
código para isso:
var
begin
usu := ExpandConstant('{userinfoname}');
org := ExpandConstant('{userinfoorg}');
Result := ValidaReg(usu,org,Serial);
end;
Em Delphi, você poderia simplesmente criar um arquivo .dpr com este conteúdo, e
compilá-lo, que já teria a DLL que exporta a função ValidaReg:
library CheckSerial;
uses
Windows;
function ValidaReg(usu, org, serial: String): Boolean; stdcall;
begin
if (usu='Marcos') and (org='Mep') and (serial='123-456-789') then
Result := True
else
Result := False;
end;
exports ValidaReg;
begin
end.
Dentro da DLL você pode programar como quiser, aí fica a seu critério. A validação do
número serial deve usar algum algoritmo criado por você, e claro, com algum sistema
gerador de seriais com base no nome de usuário que só você possua. Não se esqueça
que as DLLs interagem com os arquivos independentemente da linguagem em que
foram criados (Delphi, C++, VB, etc), já que elas são compiladas.
A integração com DLLs do Inno Setup é muito boa e estável, e permite que ele dê conta
de coisas que muitos instaladores comerciais não fazem.
Concluindo
Eis um pouco do Inno Setup. Ele ainda pode ser personalizado, de várias formas: além
do uso de DLLs, é possível adicionar páginas (telas de instalação) personalizadas, para
obter dados adicionais do usuário durante a instalação. Ou você pode ir mais longe,
baixando o código fonte do Inno e alterando diretamente os arquivos do instalador - o
que não é fácil, mas pode ser uma experiência interessante. Ele foi feito em Borland
Delphi, e é compilado pelo Jordan Russell no velho Delphi 2 - já que as versões antigas
do Delphi geram executáveis bem pequenos, perto das versões recentes ;)
Se você não gosta de manipular o script diretamente, pode experimentar o ISTool, uma
interface gráfica para o Inno Setup, que permite criar e modificar os arquivos .iss
facilmente:
Ele e várias outras utilidades podem ser baixados na página de downloads do Inno:
http://www.jrsoftware.org/is3rdparty.php
Bom trabalho :)