Neste artigo será demonstrada a utilização do compilador do Delphi por linha de comando: como acioná-lo manualmente, como automatizar a compilação de um projeto, e as diferentes possibilidades de configurações permitidas.

Para os exemplos apresentados aqui será utilizado o Delphi 7, mas as mesmas configurações poderão ser utilizadas sem muitas alterações em qualquer versão do Delphi.

O problema

A compilação de um projeto precisa ser um processo rápido e eficiente. O tempo gasto para abrir o IDE do Delphi, aguardar que ele esteja completamente carregado, abrir o projeto que precisa ser liberado, para só então dar início à compilação, será sempre maior do que o tempo realmente necessário pelo compilador para a geração do arquivo final.

A solução

Para simplificar essa tarefa, tornando-a mais ágil e confiável, temos a possibilidade de acionar o compilador por linha de comando. Esse processo, se corretamente configurado, produzirá o mesmo resultado que seria obtido ao compilar o projeto pelo IDE do Delphi.

O compilador

O compilador do Delphi é o arquivo dcc32.exe que fica localizado em $(DELPHI)\Bin. Para listar os parâmetros do compilador, basta digitar dcc32 no prompt de comando do Windows.

• Nota: Se houver mais de uma versão do Delphi instalada no computador, digitar apenas dcc32 acionará a primeira versão do compilador encontrada na variável de ambiente “PATH” do Windows. Nesses casos, para acionar uma versão específica do compilador, indique o caminho completo do arquivo dcc32.exe.

Abaixo um exemplo das informações exibidas no prompt de comando ao executar o dcc32.exe sem informar qualquer parâmetro:

C:\\>dcc32
Borland Delphi Version 15.0
Copyright (c) 1983,2002 Borland Software Corporation

Syntax: dcc32 [options] filename [options]

  -A<unit>=<alias> = Set unit alias  -LU<package> = Use package
  -B = Build all units               -M = Make modified units
  -CC = Console target               -N<path> = DCU output directory
  -CG = GUI target                   -O<paths> = Object directories
  -D<syms> = Define conditionals     -P = look for 8.3 file names also
  -E<path> = EXE output directory    -Q = Quiet compile
  -F<offset> = Find error            -R<paths> = Resource directories
  -GD = Detailed map file            -U<paths> = Unit directories
  -GP = Map file with publics        -V = Debug information in EXE
  -GS = Map file with segments       -VR = Generate remote debug (RSM)
  -H = Output hint messages          -W = Output warning messages
  -I<paths> = Include directories    -Z = Output 'never build' DCPs
  -J = Generate .obj file            -$<dir> = Compiler directive
  -JP = Generate C++ .obj file       --help = Show this help screen
  -K<addr> = Set image base addr     --version = Show name and version
Compiler switches: -$<letter><state> (defaults are shown below)
  A8  Aligned record fields           P+  Open string params
  B-  Full boolean Evaluation         Q-  Integer overflow checking
  C+  Evaluate assertions at runtime  R-  Range checking
  D+  Debug information               T-  Typed @ operator
  G+  Use imported data references    U-  Pentium(tm)-safe divide
  H+  Use long strings by default     V+  Strict var-strings
  I+  I/O checking                    W-  Generate stack frames
  J-  Writeable structured consts     X+  Extended syntax
  L+  Local debug symbols             Y+  Symbol reference info
  M-  Runtime type info               Z1  Minimum size of enum types
  O+  Optimization

Todos os parâmetros do compilador devem ser precedidos por hífen (-) ou por barra (/).

Entre os diversos parâmetros existentes, os mais relevantes para nosso exemplo são:

B: Indica que deverão ser compiladas todas as units do projeto. É equivalente à opção “Build” disponível no menu “Projects” do Delphi;

H: Habilita (-H+) ou desabilita (-H-) a exibição de hints.

Q: será realizada uma compilação silenciosa, não emitindo informações sobre todos os arquivos processados pelo compilador. Hints, warnings e erros serão exibidos normalmente.

R: Lista de diretórios nos quais o compilador irá buscar por arquivos de recursos (.RC, .RES) utilizados no projeto;

U: Lista de diretórios nos quais o compilador irá procurar arquivos .PAS ou .DCU utilizados no projeto;

W: Habilita (-W+) ou desabilita (-W-) a exibição de mensagens do compilador. Para habilitar ou desabilitar um alerta específico, basta citar os alertas após o parâmetro, precedidos de + ou -. Exemplo: -W-UNIT_PLATFORM +UNIT_DEPRECATED

• Nota: Nos parâmetros que indicam diretórios, caso mais de um diretório seja listado, eles deverão estar separados por ponto e vírgula (;).

Nosso projeto de exemplo

Vamos criar um novo projeto, que não fará nada além de produzir algumas situações que nos permitirão tirar proveito dos recursos do compilador. No Delphi 7 acesse File/New/Aplication. Adicione ao form um TFileListBox e um TButton. No evento OnClick do botão, defina o código abaixo: 

procedure TfrmPrincipal.btnFazNadaClick(Sender: TObject);
var
  i: Integer;
  s: string;
begin
  s := 'alo mamae';
  ShowMessage(s);
end;

Salve a unit como Principal.pas, salve o projeto como Compila.dpr e defina a propriedade Name do form como frmPrincipal.

Compilação manual

Vamos então começar o uso do compilador. Inicie o prompt de comando do Windows e digite o caminho do compilador seguido do caminho completo do arquivo DPR. Por exemplo:

C:\\>dcc32 T:\\ProjetoExemplo\\Compila.dpr

Ao executar esse comando será retornado um erro, indicando que o arquivo Principal.dcu não foi encontrado. Esse erro ocorre porque nenhum Principal.pas nem Principal.dcu foram encontrados nos diretórios conhecidos pelo dcc32. Uma forma simples de evitar esse problema é sempre iniciar a compilação a partir do diretório do projeto. Para isso basta alterar o diretório corrente antes de executar o compilador. Como exemplificado abaixo: 

C:\\>T:
T:\\>cd \\ProjetoExemplo
T:\\ProjetoExemplo>dcc32 Compila.dpr

Se tudo correu bem, nesse ponto a compilação foi executada sem erros, e o arquivo Compila.exe foi gerado corretamente. Porém, algumas mensagens foram exibidas pelo compilador:

Principal.pas(7) Warning: Unit 'FileCtrl' is specific to a platform
Principal.pas(29) Hint: Variable 'i' is declared but never used in TfrmPrincipal.btnFazNadaClick'

Os hints foram exibidos porque nas propriedades do projeto a opção “Show hints” está marcada, o que seria equivalente a passar o  parâmetro /H+. Os hints são importantes, pois indicam situações que podem ser melhoradas no nosso código. Afinal, se a variável “s” não é utilizada em nenhum ponto do código, para quê declará-la? É possível desabilitar a exibição de hints passando o parâmetro /H-, mas a melhor forma mesmo de evitar essas mensagens é fazendo os ajustes necessários no seu código. No nosso caso vamos então remover a declaração da variável i, que é desnecessária.

Mas, para quem desenvolve somente aplicações para Windows, qual a relevância do alerta que indica que a unit FileCtrl é específica dessa plataforma? Nenhuma. Nesse caso, para deixarmos o log enxuto, contendo apenas as mensagens realmente necessárias, podemos desabilitar esse warning listando-o no parâmetro W. Como o arquivo Principal.dcu já se encontra no diretório e nenhuma alteração foi realizada em Principal.pas ele não precisará ser compilado novamente. Para forçar a compilação de todos os arquivos do projeto vamos inserir também o parâmetro B, que indica ao compilador que deve ser realizada uma compilação de todos os arquivos. O compilador exibe informações sobre cada arquivo sendo compilado. Se desejar omitir essas informações acrescente o parâmetro Q. Ficamos então com o seguinte comando:

T:\\ProjetoExemplo>dcc32 -B Compila.dpr -Q -W-UNIT_PLATFORM

Nesse ponto a compilação deve ser executada sem qualquer dica ou alerta, ficando a saída parecida com o exemplo abaixo:

Borland Delphi Version 15.0
Copyright (c) 1983,2002 Borland Software Corporation
52 lines, 0.20 seconds, 358352 bytes code, 7749 bytes data.

Automatizando a compilação

Já conseguimos compilar nosso projeto invocando manualmente o compilador pelo prompt de comando. Mas, como o processo de compilação precisa ser repetido inúmeras vezes, a qualquer tempo, não seria conveniente a cada compilação digitarmos os comandos no prompt. Para automatizar esse processo, podemos criar um arquivo de script com os comandos necessários. Crie um novo arquivo .CMD e insira nele os comandos. Segue o conteúdo do meu arquivo Compila.cmd:

@echo off
set PRJ=Compila.dpr
set DRIVE_PRJ=T:
set DIR_PRJ=\\ProjetoExemplo
set DIR_DELPHI=c:\\Progra~1\\Borland\\Delphi7\\Bin
set COMP_MSGS=-UNIT_PLATFORM

%DRIVE_PRJ%
cd %DIR_PRJ%
%DIR_DELPHI%\\dcc32.exe -B %PRJ% -Q -W%COMP_MSGS%

Algumas variáveis foram criadas no arquivo para simplificar a manutenção dos comandos de compilação. Embora a definição dessas variáveis não seja indispensável para esse processo, seu uso é recomendável.

Agora temos uma forma automatizada de compilar nosso projeto, bastando para tanto executar o arquivo Compila.cmd, seja pelo prompt de comando, ou mesmo pelo Windows Explorer.

Definindo os diretórios de componentes

Se utilizássemos em nosso projeto componentes de terceiros, os diretórios onde se encontram seus arquivos de recursos e units precisariam ser informados para o compilador. Para isso são disponibilizados os parâmetros R e U.

Se, por exemplo, utilizássemos um TJvFileListBox, que é um componente da JVCL, bastaria indicar os diretórios da JVCL em nosso arquivo. Como no exemplo abaixo:

@echo off
set PRJ=Compila.dpr
set DRIVE_PRJ=T:
set DIR_PRJ=\\ProjetoExemplo
set DIR_DELPHI=c:\\Progra~1\\Borland\\Delphi7\\Bin
set COMP_MSGS=-UNIT_PLATFORM
set SEARCH_PATH=D:\\Delphi\\jcl\\lib\\d7;D:\\Delphi\\jvcl\\lib\\d7
set RES_PATH=D:\\Delphi\\jvcl\\resources

%DRIVE_PRJ%
cd %DIR_PRJ%
%DIR_DELPHI%\\dcc32.exe -U%SEARCH_PATH% -R%RES_PATH% -B %PRJ% -Q -W%COMP_MSGS%

Configurações por projeto

Em alguns projetos é comum utilizarmos vários componentes de terceiros, habilitarmos ou desabilitarmos mensagens do compilador, entre tantas outras configurações que podem ser alteradas com freqüência. Embora o nosso arquivo de script permita configurar todas essas opções atualizá-lo à cada mudança das configurações do projeto não será uma tarefa tão cômoda. Uma maneira mais simples de realizar essas configurações é através das opções do projeto (menu Project/Options). As configurações alteradas pelas opções do projeto serão salvas nos arquivos Compila.cfg e Compila.res, que serão automaticamente lidos pelo dcc32.exe.

• Nota: ao utilizar configurações personalizadas por projeto, não se esqueça de adicionar os arquivos .CFG .RES ao controle de versão.

Vamos tirar proveito da facilidade das configurações visuais e organizar um pouco nosso projeto. Crie os diretórios bin e dcu dentro do diretório do projeto. Nesses diretórios serão colocados respectivamente o arquivo de saída do nosso projeto (.EXE, .DLL, etc.) e os arquivos .DCU. Para indicar ao compilador como usar esses diretórios acesse as opções do projeto. Na aba “Directories/Conditionals” preencha os campos “Output directory” e “Unit output directory”.

No campo “Search path” indique os diretórios dos componentes utilizados no projeto.

Caso no projeto sejam utilizadas diretivas de compilação, bastaria indicá-las no campo “Conditional defines”.

Na aba “Compiler messages” certifique-se que as opções “Show hints” e “Show warnings” estejam selecionadas. Uma lista de warnings é exibida nessa aba, permitindo desabilitar aquelas que não são relevantes para o projeto.

Após concluir essas configurações não será mais necessário indicar no nosso arquivo de script os diretórios de recuros e de units, nem mesmo indicar os alertas que deverão ser desabilitados, o que reduzirá o conteúdo do arquivo:

@echo off
set PRJ=Compila.dpr
set DRIVE_PRJ=T:
set DIR_PRJ=\\ProjetoExemplo
set DIR_DELPHI=c:\\Progra~1\\Borland\\Delphi7\\Bin

%DRIVE_PRJ%
cd %DIR_PRJ%
%DIR_DELPHI%\\dcc32.exe -B %PRJ% -Q

Configurações por máquina

Com a utilização do arquivo de configurações do projeto ganhamos a possibilidade de realizar uma edição visual das configurações da compilação.

Normalmente um build completo só é realizado na máquina de liberação de versão, o que fica a cargo do administrador do projeto, mas é possível que um projeto possua vários desenvolvedores, trabalhando cada um em sua máquina, ou mesmo trabalhando remotamente, em ambientes diferentes, e seja necessário ou desejado que todos possam utilizar as mesmas configurações de compilação nos diversos ambientes. Nesses casos, utilizar um único arquivo de configuração por projeto exigirá que em todas as máquinas os componentes estejam instalados nos mesmos diretórios, ou ao menos estejam em uma estrutura de diretórios que possa ser referenciada por caminhos relativos. O que pode ser um problema se no projeto trabalharem desenvolvedores free-lancers. Uma forma de contornar esse problema é referenciando os componentes por diretórios virtuais, criados pelo comando subst no prompt de comando do Windows. Mas, ainda assim, seria necessário que os mesmos diretórios virtuais fossem criados em todos os computadores. Outra maneira é utilizar configurações gerais por máquina.

Sempre que o compilador é acionado ele busca por configurações no arquivo dcc32.cfg que se encontra no mesmo diretório que o arquivo dcc32.exe, depois procura pelo arquivo dcc32.cfg no diretório do projeto e, finalmente, pelo arquivo NomeDoProjeto.cfg, no nosso caso Compila.cfg, no diretório do projeto. Todas as configurações são consideradas, o que significa que podemos fazer uso de mais de um arquivo ao mesmo tempo. Para o problema citado acima, onde cada máquina pode possuir configurações diferentes, os parâmetros referentes a diretórios componentes poderiam ser definidos em $(Delphi)\Bin\dcc32.cfg, pois podem variar por máquina, e as demais configurações que são gerais, como exibição de alertas, diretivas de compilação, e diretórios para geração de dcus e binários, poderiam ser mantidas no arquivo de configuração do projeto.

O dcc32.cfg pode também ser utilizado para definir configurações e diretórios que se apliquem a todos os projetos utilizados em um determinado ambiente. Fazendo uma analogia com o IDE do Delphi, os diretórios definidos no dcc32.cfg seriam equivalentes aqueles definidos no library path (Tools/Environment options/Library/Library path) tendo, portanto, visibilidade global, válida para todos os projetos; já os diretórios definidos em NomeDoProjeto.cfg são aqueles visíveis pelo Search path(Project/Options/Directories/Conditionals/Search path) e são específicas do projeto em questão.

O arquivo dcc32.cfg deve ser editado manualmente. Para facilitar pode-se copiar o conteúdo do arquivo de configurações do projeto, mas a cada alteração em diretórios ele precisará ser atualizado novamente.

Recursos não disponíveis

Um recurso do qual você pode sentir falta ao utilizar o compilador por linha de comando é o incremento automático do número da versão do arquivo. Ainda que essa opção tenha sido selecionada nas configurações do projeto, ela não terá efeito, pois não se trata de uma funcionalidade do compilador, mas sim do IDE do Delphi. Uma saída para continuar incrementando a versão do arquivo, seria desenvolver um utilitário com essa funcionalidade, e invocá-lo no arquivo de script, mas isso é assunto para outro artigo.

Considerações finais

Como vimos, a compilação de projetos por linha de comando é um recurso simples de ser utilizado que pode nos auxiliar muito na padronização do processo de compilação e liberação de versões, tornando essa tarefa mais ágil e confiável.

Caso precise de uma automação completa do processo de liberação de versão, vale a pena conhecer algumas das ferramentas interessantes disponíveis atualmente para essa finalidade, entre as quais tem destaque a comercial FinalBuilder, e as gratuitas Rake e MSBuild, sendo essa última a ferramenta padrão de build do Delphi2007.

Espero com esse artigo ter contribuído de alguma forma para a melhoria do seu processo de compilação.

Comentários, críticas e sugestões serão muito bem-vindos para que os próximos artigos possam ser aprimorados.

Você pode baixar essa instalação clicando aqui. As instruções de como instalar estão dentro do arquivo “instalar.txt“.

A partir do Delphi 2006 o gerenciador de memória padrão que acompanha o Delphi passa a ser o FastMM. Quem não trabalha com Delphi 2006 pode baixar o FastMM aqui.

Se você estiver começando agora a desenvolver com Delphi deve estar se perguntando: Tá, e dai? O que é memory leak?

Memory leak é um objeto criado pela aplicação que não foi corretamente destruído.

Você pode simular esta situação criando qualquer objeto no OnCreate do formulário principal da sua aplicação. Exemplo:

procedure TForm1.FormCreate(Sender: TObject);
var
  lstVazamento : TStrings;
begin
  lstVazamento := TStringList.Create;
  try
    lstVazamento.Add('Linha 1');
    lstVazamento.Add('Linha 2');
    lstVazamento.Add('Linha 3');
  finally

  end;
end;

Execute o aplicativo e feche-o. Você notará que não acontece nada!

Esse teste ridículo foi feito só para você ver como é comum ocorrerem problemas que resultem em vazamentos de memória (memory leaks) como a falta de atenção (nesse caso), a pressa, Control+C / Control+V entre alguns outros.

Agora insira esta linha logo após o begin da sua procedure:

ReportMemoryLeaksOnShutdown := True;

Deixando o código assim:

procedure TForm1.FormCreate(Sender: TObject);
var
  lstVazamento : TStrings;
begin
  ReportMemoryLeaksOnShutdown := True;

  lstVazamento := TStringList.Create;
  try
    lstVazamento.Add('Linha 1');
    lstVazamento.Add('Linha 2');
    lstVazamento.Add('Linha 3');
  finally

  end;
end;

Repita a operação e veja o que acontece após fechar o aplicativo:

Veja que recebemos a notificação do TStringList que criamos e das 3 linhas que adicionamos (String x 3) a ele. A partir dai podemos começar a evitar esse tipo de erro na hora de desenvolvermos aplicativos.

Uma dica importante é você utilizar o bloco try…finally…end; sempre que criar um objeto dinamicamente. Isto evita que ocorra um erro no meio da execução e ele não seja destruído devidamente. Veja os dois exemplos:

Método não apropriado:

procedure TForm1.FormCreate(Sender: TObject);
var
  lstVazamento : TStrings;
begin
  ReportMemoryLeaksOnShutdown := True;

  lstVazamento := TStringList.Create;
  lstVazamento.Add('Linha 1');
  lstVazamento.Add('Linha 2');
  lstVazamento.Add('Linha 3');
  lstVazamento.Free;
end;

Método apropridado de utilização:

procedure TForm1.FormCreate(Sender: TObject);
var
  lstVazamento : TStrings;
begin
  ReportMemoryLeaksOnShutdown := True;

  lstVazamento := TStringList.Create;
  try
    lstVazamento.Add('Linha 1');
    lstVazamento.Add('Linha 2');
    lstVazamento.Add('Linha 3');
  finally
    lstVazamento.Free;
  end;
end;

Utilizando o bloco try…finally…end; mesmo que ocorra algum erro na execução do procedimento o objeto é destruído. Pelo método não apropriado lstVazamento não seria destruído caso ocorresse algum problema na execução da linha lstVazamento.Add(‘Linha 1′);, por exemplo.

Em tempo: utilizando ReportMemoryLeaksOnShutdown := True; a mensagem ocorrerá sempre que o aplicativo for terminado, inclusive fora do Delphi. Para evitarmos esse situação, substitua o True por DebugHook <> 0; deixando a linha assim:

ReportMemoryLeaksOnShutdown := DebugHook <> 0;

Para quem utiliza outras versões do Delphi isto deve ser configurado no arquivo FastMM4Options.inc.

No próximo artigo abordaremos mais funções do FastMM e configurações do arquivo FastMM4Options.inc para quem utiliza FastMM em versões mais antigas do Delphi. Até mais!

• .dcu, .dpu, .dcuil

DCU, ou “Delphi Compiled Unit”, contém o código compilado de uma unit .pas, e, opcionalmente, informações de debug que podem ser usadas posteriormente pela IDE. O .dpu é o correspondente do Kylix, e .dcuil é o mesmo arquivo gerado pelo compilador de Delphi para .Net

• .dcp, .dcpil

O arquivo .dcp é uma espécie de conjunto de todos os DCUs que formam uma package. O .dcpil é a versão .net desses dados, onde também é gerado pelo compilador Delphi ao importar assemblies escritos em outras linguagems, como C#.

• .exe

Geralmente o que você espera que saia de uma compilação: o executável do seu projeto.

• .dll, .bpl

DLLs são bem conhecidas de desenvolvedores windows: são bibliotecas que podem ser compartilhadas por vários executáveis, ou simplesmente servir para modularizar projetos. BPL é uma DLL com informações extras adicionadas pelo compilador Delphi, permitindo compartilhar tipos entre módulos e o executável de forma mais fácil.

• .map, .rsm, .pdb

São arquivos opcionais, habilitados nas opções de projeto, contendo informações de debug. O primeiro contém informações sobre a relação do conteúdo do código fonte e o código gerado, o segundo possui dados específicos para o remote debugger. Arquivos .pdb são informações de debug externas geradas para aplicações .net

• .xml

Se habilitado nas opções de projeto, o compilador também gera arquivos XML contendo documentação sobre as classes, extraídas das suas declarações e de comentários que se relacionam à elas.

• .drc

Se for gerado um map file detalhado, também será gerado um arquivo .drc contendo uma lista de todos os recursos que o compilador incluiu no executável.

• .hpp, .obj, .lib

Pra quem usa C++ Builder, se for habilitado a opção de gerar arquivos para o C++ nas opções de um projeto Delphi, o compilador também gera o .hpp, que é um header de C++ contendo as declarações do que estiver nos seus arquivos .pas. O .obj é o correspondente do .dcu para o C++, e o .lib, corresponde do .dcp. Útil para quem escreve componentes VCL para usar tanto no Delphi quanto no C++.

Sabendo pra que servem os arquivos gerados, e quando são gerados, fica mais fácil gerenciar os arquivos de um projeto, e decidir o que pode ser apagado e o quais devem estar no controle de versão.

Olá pessoal, resolvi colocar uma dica bacana para quem desenvolve pacotes de componentes.

Quem utiliza o BDS já reparou que alguns packages, depois de carregados, exibem um pequeno bitmap de 24×24 px. com a descrição do pacote de ferramentas e a empresa desenvolvedora na tela de inicialização da IDE. Podemos citar entre eles o JediVCS, RemObjects, TMS Component Pack entre outros.

Neste pequeno artigo quero mostrar como é fácil e rápido personalizarmos nossos pacotes de componentes com este recurso que a IDE nos oferece.

Primeiramente devemos criar o nosso arquivo de recurso (.RES) com a imagem bitmap que irá ser apresentada na inicialização da IDE. Para isso você pode utilizar qualquer ferramenta de edição de recursos, até mesmo na linha de comando, compilando um arquivo texto com o aplicativo que a Code Gear nos disponibiliza, o BRCC32. Eu recomendo o XN Resource Editor(XRE), desenvolvido por Colin Wilson (Xana News), que além de ser muito bom é FREE. Para baixá-lo acesse o site: http://www.wilsonc.demon.co.uk/delphi.htm (vou utilizar ele como base para terminar este artigo mas você pode criar o arquivo da maneira que bem entender, desde que o recurso possua o mesmo nome deste exemplo ou você adapte este exemplo).

Criando o arquivo de recurso:

1. Dentro do XRE clique no menu “Resource” e selecione a opção “Import Image Resource”. Escolha uma imagem Bitmap de 24×24 px;
2. Após inserir esta imagem o XRE a adicionará no grupo “Bitmap” e o nome dela será “1″;
3. Clique no nome “1″ e renomeie para “SPLASH_TECHTIPS”;
4. Salve o arquivo com o nome SPLASH_TESTE.RES na pasta do seu projeto de componentes.

Criando a unit de registro do seu splash:

Crie uma unit em branco e adicione ao seu pacote de componentes com a seguinte estrutura:

unit SplashTeste;

interface

{$R SPLASH_TESTE.RES} 

implementation

uses
  Graphics, ToolsAPI;

procedure AddSplash;
var
  bmpAux : TBitmap;
begin
  bmpAux := TBitmap.Create;
  try
    bmpAux.LoadFromResourceName(HInstance, 'SPLASH_TECHTIPS');

    {$IFDEF VER180}
      SplashScreenServices.AddPluginBitmap('Meus componentes',
        bmpAux.Handle,
        False,
        'Licenciado para TechTips', '');
    {$ENDIF}

  finally
    bmpAux.Free;
  end;
end;

begin
  AddSplash;

end.

Agora recompile seu pacote de componentes e instale-o novamente.

Reinicie a sua IDE e veja o resultado!

Primeiramente, um package e adicione um novo form nele. Crie uma seção published na declaração do form e adicione qualquer propriedade que quiser. No meu caso, a declaração ficou assim:

type
  TFormComPropriedades = class(TForm)
  private
    FMensagem: string;
  published
    property Mensagem: string read FMensagem write FMensagem;
  end;

Crie uma nova unit, adicione DesignIntf e DesignEditors no uses da implementação, e inclua uma função Register, ficando tudo assim assim:

unit FormPropReg;

interface

procedure Register;

implementation

uses UnitFormProp, DesignIntf, DesignEditors;

procedure Register;
begin
  RegisterCustomModule(TFormComPropriedades, TCustomModule);
end;

end.

Clique com o botão direito no designer do form e selecione Add To Repository. Preencha os dados pra ele aparecer na lista de forms que podem ser herdados. Compile o package, clique com o botão direito sobre ele no Project Manager e selecione Install.

Agora é só criar uma nova aplicação, ir em File/New/Other, escolher o formulário que foi adicionado anteriormente, selecionar inherit (e não copy!), e pronto. As propriedades devem então aparecer no object inspector:

1. Vá em Tools/Configure Tools.
2. Adicione um novo item. Dê o nome de “Explorer”.
3. Preencha a opção “program” com “explorer“.
4. Em “parameters”, coloque “/e,/select, $EDNAME“.

E pronto. Agora, selecionando Tools/Explorer, o Windows Explorer vai abrir e selecionar o arquivo que está ativo na IDE do Delphi automaticamente.