Delphi@Brasil Magazine - Fevereiro 98
Tópico do mês : Visualização de um formulário de maneira correta independente da resolução do monitor o qual roda nossa aplicação.
Isto sem dúvida alguma é um dos problemas que mais dão dor de cabeça aos usuários do Delphi, nas listas de discussão são um dos tópicos que mais são discutidos, porém na maioria das vezes as soluções sugeridas não satisfazem totalmente o programador. Inclusive a Borland já liberou um TI(Technical Information) tentando solucionar o problema, mas a solução adotada por ela não é das mais eficazes. Vamos tentar explicar como de uma maneira simples você pode controlar esta visualização mas para ter um controle a nível profissional serão necessários os controles de muitos detalhes, os quais vamos esclarecer na medida do possível.
O detalhe inicial que temos a entender é a relação matemática que existe entre a resolução no qual o nosso aplicativo foi criado e a resolução no qual ele irá ser executado. Por exemplo se desejamos que um formulário que numa resolução de 640X480 têm 320X240, permaneça com as mesmas relações de proporcionalidade entre seu tamanho e a resolução do monitor (notar que é de 2:1) necessitamos seguir esta escala em qualquer resolução a que seja submetido o formulário. Por exemplo numa resolução de 800X600 nosso formulário terá que adquirir as dimensões de 400X300 pois só assim satisfazemos a condição de que o formulário deve ter 50% da resolução na altura e na largura.
Eu tenho visto soluções mirabolantes por aí que passam desde do tratamento de componente por componente pertecente a um formulário até parametrizações para cada resolução do monitor, no entanto a solução é mais simples do que se pode imaginar. O Delphi possui um método pertencente a WinControl denominado ScaleBy onde nele são passados como parâmetros dois inteiros que representam a relação entre si da escala anterior e a nova escala a ser ajustada. Por exemplo se criamos um formulário numa resolução de 640 e estamos numa resolução de 800 o método será invocado desta forma :
TWinControl.ScaleBy(800, 640);
Notar que esta é uma relação de divisão que irá dar um resultado de 800/640 = 1,25 ou seja 125% do tamanho original do componente. Vamos analisar este resultado. Se inicialmente para ocuparmos com um fomulário o percentual X da resolução do monitor, e esta resolução no momento atual é de X * 1,25( ou seja 640*1,25), também será necessário ao nosso formulário e a todos os componentes que o pertencem serem incrementados nesta escala para mantermos a relação entre resolução e tamanho do formulário.
Como vimos é muito simples, bastariámos que criassemos uma chamada a este método em cada OnCreate do próprio formulário desta forma :
procedure
TForm1.FormCreate(Sender: TObject);
begin
{ Notar que o Self antes de ScaleBy se refere ao
próprio formulário }
Self.ScaleBy(800,640); // No caso de nossa aplicação ser
desenvolvida em 640X480
end;
Porém as coisas não são tão simples assim, primeiro porque a boa programação nos diz que não devemos usar diretamente o valor de constantes nas chamadas de métodos e funções, e segundo por que como veremos adiante, se não tomarmos alguns cuidados a cura pode ficar pior do que a doença. Vamos por partes para vermos todos os cuidados a serem tomados para as coisas não sairem erradas :
É necessária que a propriedade Scaled de cada formulário esteja como True pois caso o contrário não ocorrera nenhuma mudança no Form ou nos componentes a ele pertencente.
Dê preferência a desenvolver seus aplicativos com fontes do tipo True Type (Arial é uma boa escolha) pois estas fontes se adequam conforme cálculos matemáticos as novas resoluções, permanecendo mais fiéis ao seus tamanhos iniciais.
Escolha preferencialmente a resolução de 640X480 para desenvolver seus aplicativos, pois se você fizer teste verificará que se partir de resoluções maiores dos seus aplicativos para resoluções menores, nos computadores dos usuários aumentarão as possibilidades de truncamento, já que todos os componentes terão que se adequarem a um tamanho de formulário menor do que quando foi projetado.
Nunca deixe a propriedades de Labels AutoSize como False, desta forma você poderá vê-los truncados quando a resolução do monitor for alterada, a não ser que você deixe seu alinhamento de forma central e coloque uma boa margem de segurança, 25% de espaço vazio é um bom número.
Nunca deixe componentes muito próximos uns aos outros, pois com a mudança de escala poderá ocorrer uma sobreposição dos componentes.
A partir dessas premissas podemos dar início ao nosso aplicativo de teste o qual possui apenas um label e um botão de Ok, coloquemos sua propriedade de Scaled como True(padrão), seu Width com 320 e seu Height com 240 como pode ser visto na figura I, e no evento OnClick de nosso botão coloquemos a sequinte declaração :
procedure TForm1.BitBtn1Click(Sender: TObject);
begin
ShowMessage('Meu Comprimento é De : '
+ IntToStr(Self.Width) + ' , e minha altura de : ' +
IntToStr(Self.Height));
end;
Ao executarmos nosso aplicativo numa resolução de 640X480 e clicarmos no botão Ok veremos a tela conforme a figura I :
Figura I
Ao alterarmos a resolução de nosso monitor e executarmos novamente o aplicativo vamos verificar que a mensagem não muda, pois bem até o momento não incluimos a declaração para o controle de escala, o que faremos neste momento no código OnCreate de Form como pode ser visto abaixo :
procedure TForm1.FormCreate(Sender: TObject);
Const
nTamOriginal = 640; // Será o 100% da
escala
Var
nEscala : Double; // Vai me dar o
percentual de Transformação escalar
nPorcento : Integer; // Vai me dar em
percentual inteiro o valor
begin
if nTamOriginal <> Screen.Width
then
begin
nEscala :=
((Screen.Width-nTamOriginal)/nTamOriginal);
nPorcento :=
Round((nEscala*100) + 100);
Self.ScaleBy(nPorcento,100);
end;
end;
Ao executarmos o nosso aplicativo numa resolução de 800X600 verifica-se a tela semelhante ao da figura II, notar que nossos componentes realmente acompanharam um crescimento de escala, tanto o botão quanto o label, porém se clicarmos no botão ele nos exibirá que seu comprimento e a altura ainda são de 320X240 o que houve ?
Figura II
É que o ScaleBy simplesmente muda de escala todos os componentes disponíveis no TWinControl, que no caso é nosso Form, porém da maneira como fizemos nosso código fica muito simples ajustar o tamanho do Form, bastando para isso usar nossa variável nEscala e multiplicá-la pelas propriedades Width e Height de TForm, não esquecendo que essas propriedades são do tipo Integer, e nosso nEscala é um Float, portanto para fazer nossa transformação temos que arredondar o nosso novo comprimento e altura. Para isso acrescente o código abaixo (só o que está em negrito) :
procedure TForm1.FormCreate(Sender: TObject);
Const
nTamOriginal = 640; // Será o 100% da escala
Var
nEscala : Double; // Vai me dar o percentual
de Transformação escalar
nPorcento : Integer; // Vai me dar em
percentual inteiro o valor
begin
if nTamOriginal <> Screen.Width then
begin
nEscala :=
((Screen.Width-nTamOriginal)/nTamOriginal);
nPorcento :=
Round((nEscala*100) + 100);
Self.Width :=
Round(Self.Width * (nEscala+1));
Self.Height :=
Round(Self.Height * (nEscala+1));
Self.ScaleBy(nPorcento,100);
end;
end;
Agora ao executarmos o nosso aplicativo na resolução de 800X600 e clicarmos o nosso botão verifica-se a tela mostrada na figura III, com nossas dimensões satisfazendo exatamente nossos anseios de termos a mesma escala de nossos componentes independente da resolução que esteja sendo usado nos monitores dos usuários de nosso aplicativos.
Figura III
Se desejar dar uma olhada no código que criamos você pode baixá-lo aqui.
- Esperamos que as informações aqui contidas tenha lhe sido de grande utilidade. Venho reforçar o pedido para que se desejarem entrem em contato conosco por meio de [email protected] , e também lembrá-los que estamos abertos a publicar matérias vindas de nossos leitores para que desse modo possamos melhorar ainda mais os nossos serviços para os leitores e servir de vitrine para o autor da matéria.
Fúlvio C. Albuquerque
Editor responsável
