Delphi Basico, Notas de estudo de Análise de Sistemas de Engenharia

código fonte provocaram o efeito desejado. Ao final desse imenso trabalho de estruturação da interface, centenas, ou até mesmo, milhares de linha de código haviam sido escritas para que tudo estivesse de acordo com o planejado pela equipe de programadores visuais responsáveis pelo projeto da interface. Tendo como um de seus objetivos facilitar todo esse processo de desenvolvimento de software, responsável muitas vezes por grande parte do tempo gasto durante o desenvolvimento, surgiram os chamados Ambientes Visuais de Desenvolvimento.

A grande popularidade desses ambientes veio do fato de que eles vieram a permitir o desenvolvimento de programas simples e complexos com pouco, ou até mesmo nenhum, esforço de programação. A dificuldade com o desenvolvimento das interfaces para os programas desenvolvidos para o ambiente Windows praticamente deixou de existir. Para o programador, deixou de existir a necessidade de conhecer, entre outras coisas, uma variedade de comandos para o posicionamento dos diversos objetos que deveriam ser colocados nas janelas do Windows.

Agora, para o programador, o desenvolvimento da interface seria feito de forma tão simples quanto se ele estivesse desenhando a interface em sua própria janela. O desenho da interface é feito colocando-se os componentes desejados nas janelas e ajustando suas propriedades como, por exemplo, sua largura e altura, de tal forma que a interface tome o aspecto desejado sem a necessidade de qualquer codificação por parte do programador. Por esse motivo, alguns autores chamam esse tipo de desenvolvimento rápido de interfaces de WYSIWYG, sigla originária do inglês What You See Is What You Get , que significa “O que você vê é o que você obtém”, referenciando justamente a forma de desenvolvimento das interfaces nessas Ambientes Visuais de Desenvolvimento. Devido a grande facilidade com que as interfaces dos aplicativos passaram a ser desenvolvidas, uma grande parte do tempo gasto no seu desenvolvimento passou a ser economizado. Por esse motivo, alguns autores chamam esse tipo de ambiente de desenvolvimento de aplicações de RAD, que significa Rapid Application Development , do inglês “Desenvolvimento Rápido de Aplicações”. A utilização desses ambientes diminui consideravelmente o tempo e, principalmente, o custo de desenvolvimento de aplicações.

Como conseqüência dessas facilidades e praticidade de desenvolvimento de aplicações para o ambiente Windows, é cada vez maior a procura e a aceitação de Ambientes Visuais de Desenvolvimento como o Microsoft Visual Basic (um dos pioneiros), o PowerBuilder, o Centura (antigo SQL Windows), além, é claro, do próprio Delphi.

Devemos observar que o simples fato do desenvolvimento da interface da aplicação não finaliza a tarefa do desenvolvimento. Resta ainda ao programador escrever o código que deverá ser executado quando o usuário tomar determinadas ações como, por exemplo, pressionar o botão de saída do programa.

Sob esse novo modelo de desenvolvimento, os programas passam a ser desenvolvidos através de um novo ponto de vista. Os programas passam a ser formados por objetos que vão sendo colocados em suas janelas (trataremos do conceito de objetos posteriormente nesta apostila), pelo ajuste de suas propriedades, para que esses objetos tenham as características desejadas pelos desenvolvedores, e pelos eventos aos quais esses objetos irão responder isto é, as possíveis ações realizadas pelos usuários do sistema ou pelo próprio sistema, como por exemplo, o clicar do mouse sobre um botão.

A utilização desse novo modelo é, por muitas vezes, a parte mais difícil no processo de migração do desenvolvimento de programas das antigas linguagens procedurais para os novos ambientes de desenvolvimento baseados em eventos. O programador não pode mais supor uma ordem exata na execução do seu código fonte e deve passar a tratar isoladamente cada evento relevante de sua aplicação.

Por exemplo, suponhamos um programa de banco de dados que possua um cadastro de clientes. Nesse programa temos uma tela onde o usuário do sistema deverá cadastrar cada cliente que irá pertencer ao banco de dados da aplicação. Nos sistemas mais antigos, não baseados no ambiente Windows, o preenchimento de cada campo era feito de forma seqüencial, verificando-se facilmente se o valor para cada um deles estava sendo colocado corretamente. Além disso, a verificação de campos de preenchimento obrigatório era facilmente efetuada uma vez que, para chegar ao local de confirmação da inclusão, o usuário deveria ter passado por todos os campos da tela de cadastro, preenchendo-os corretamente. Contudo, com o desenvolvimento de aplicativos para o ambiente Windows, não podemos mais fazer tais suposições. Agora, na janela de cadastro de clientes, o usuário não é mais obrigado a pressionar o botão de confirmação de inclusão de um novo cliente apenas após o total preenchimento de seus campos. Cuidados adicionais devem ser tomados para que isso não ocorra. Um outro exemplo bastante simples e que ocorre com freqüência cada vez maior em nosso dia-a-dia está no próprio encerramento do programa. A maneira mais corriqueira de se finalizar um aplicativo por parte do usuário é através da escolha de uma opção de saída existente na aplicação. Porém, qualquer usuário poderia finalizar o aplicativo através de um clique no ícone de sistema localizado no canto superior direito das janelas da aplicação. Um usuário mais experiente do ambiente Windows poderia também pressionar as teclas de atalho ALT + F provocando o fechamento da janela da aplicação. Em cada um desses três casos, é função do desenvolvedor fornecer o mesmo tratamento para cada uma dessas ações do usuário. Pudemos ver que os programas não irão mais seguir aquela ordem linear de execução que programas mais antigos seguiam, mas sim uma execução baseada em eventos. A ordem de execução do programa irá seguir a ordem dos eventos que cada usuário do aplicativo desejar. Devemos perceber que, internamente ao tratamento de cada evento, a execução das instruções contidas no código do programa ainda continua, de certa forma, linear porém, a escolha de qual desses códigos ou seja, a execução dos eventos por parte do usuário do aplicativo, a ser executado é que não é mais linear. Mesmo com essa aparente dificuldade, o desenvolvimento de aplicações através de tais ambientes é, e continuará a ser durante muito tempo, o método mais rápido e eficiente de desenvolvimento de aplicações para o ambiente Windows.

1.3. O que é o Delphi

Como mencionado, o Delphi é um Ambiente Visual de Desenvolvimento colocado no mercado pela empresa americana Borland, atualmente chamada Inprise. O Delphi tornou-se uma verdadeira febre dentre os programadores de aplicativos espalhados por todo o mundo devido as suas inúmeras vantagens em relação à outras linguagens de programação para o ambiente Windows como, por exemplo, o Microsoft Visual Basic. Através da utilização da linguagem Object Pascal, linguagem esta oriunda do Pascal porém fornecendo suporte à programação orientada a objetos, o Delphi possibilita a criação rápida de aplicativos para o ambiente Windows, ou seja, o Delphi é uma ferramenta RAD para o ambiente Windows. Porém, como toda ferramenta que se apresenta como um meio para facilitar o desenvolvimento de novos aplicativos, o Delphi tem sua contrapartida com relação a todas essas vantagens. O equipamento necessário para a instalação e execução do Delphi é bem mais robusto do que as antigas linguagens de programação como C/C++ e versões anteriores do Pascal e do próprio Object Pascal. Para a instalação do Delphi 5.0, dependendo de qual versão esteja sendo instalada (Standard, Professional ou Enterprise) se faz necessário o seguinte equipamento (no caso da versão Enterprise):

• Computador com processador Pentium 90 ou superior

Barra de Título e Menus

Barra de Atalho

Paleta de Componentes

Object Inspector Formulário

Editor de Código

2. O Ambiente de Desenvolvimento do Delphi

O Delphi, conforme citado anteriormente, ao contrário do que muita gente pensa, é um Ambiente Visual de Desenvolvimento e não uma linguagem de programação. Não existe, como dito erroneamente por muitos, a linguagem de programação chamada Delphi, mas sim um Ambiente Visual de Desenvolvimento que foi chamado de Delphi. Já esse ambiente utiliza a linguagem de programação chamada Object Pascal. Dessa forma, iremos iniciar nosso estudo de Delphi através de seu Ambiente de Desenvolvimento, também chamado de IDE, do inglês Integrated Development Environment, passando posteriormente ao estudo da linguagem de programação Object Pascal. Após o término da instalação do Delphi, podemos iniciar a sua IDE através do ícone Delphi 5 localizado na pasta Borland Delphi 5 como ilustrado na figura a seguir.

Uma vez inicializada a IDE do Delphi surgirão, inicialmente, 4 janelas que irão permitir ao desenvolvedor trabalhar e desenvolver suas aplicações no Delphi, como ilustra a figura abaixo.

Existem ainda outras janelas que poderiam ser exibidas dentro da IDE do Delphi dependendo das configurações definidas pelo desenvolvedor, porém as 4 janelas exibidas acima constituem a instalação e configuração básicas do Delphi. Antes de aprendermos a linguagem Object Pascal

devemos nos familiarizar com o ambiente no qual iremos trabalhar, ou seja, devemos aprender como manipular a IDE do Delphi. Dessa forma, veremos cada uma das janelas que compõe a IDE mais detalhadamente a seguir.

2.1. A Janela Principal

A janela principal da IDE do Delphi é dividida em 3 partes, são elas: a Barra de Título e Menus, a Barra de Ferramentas e a Paleta de Componentes. Apesar de termos essas divisões, apenas a primeira é necessária para que a IDE do Delphi esteja em execução, podendo as duas outras, a Barra de Atalho e a Paleta de Componentes, bem como todas as demais janelas citadas anteriormente, estarem ocultas, de acordo com a vontade do desenvolvedor. Comecemos, então, nossa exploração pela IDE do Delphi através de sua Barra de Título e Menus. Na Barra de Título e Menus encontramos todas as opções que o desenvolvedor necessitará para a utilização do ambiente do Delphi. Através dos diversos menus aí localizados, o desenvolvedor poderá criar novas aplicações, dar manutenção em aplicações previamente desenvolvidas, além de configurar todo o seu ambiente de trabalho de acordo com a sua forma de programação. Veremos os principais itens de menu existentes na janela principal a medida em que formos utilizando a IDE do Delphi. A Barra de Ferramentas, também chamada de Barra de Atalhos, localizada do lado inferior esquerdo da janela principal é utilizada para acessar as funções mais freqüentemente utilizadas pelo desenvolver Delphi. Nela encontramos opções tais como a abertura e salva de arquivos de código- fonte Object Pascal, compilação, execução e depuração de programas, entre outras. É importante observarmos dois pontos com relação a Barra de Ferramentas. O primeiro é que ela contém opções que também estão à disposição do desenvolvedor através de itens de menus, permitindo no entanto, um acesso mais rápido a elas. O segundo ponto, como dito anteriormente, é que ela não precisa estar visível para que a IDE do Delphi esteja ativa. Para ocultarmos a Barra de Ferramentas basta clicarmos com o botão secundário do mouse sobre ela fazendo surgir na tela um menu Popup. Nesse menu existirá diversos itens que permitem ao desenvolvedor ocultar ou não as diversas barras que compõe a Barra de Ferramentas, conforme ilustra a figura ao lado. Através do menu Popup mostrado ao lado, podemos deixar ou não visíveis cada um dos 6 grupos de botões da Barra de Ferramentas do Delphi, além da Paleta de Componentes que será vista a seguir. Esse menu Popup poderá também ser selecionado através do menu View -> Toolbars localizado na janela principal do Delphi. A IDE do Delphi permite ainda que a Barra de Ferramentas possa ser configurada de acordo com as necessidades do desenvolvedor. Isso poderá ser feito através do menu Customize mostrado na figura anterior. Ao selecionarmos essa opção será exibida a caixa de diálogo Customize como mostrado na figura a seguir. Através dessa caixa de diálogo o desenvolvedor poderá definir também quais componentes da Barra de Ferramentas estarão visíveis, através das opções localizadas na página Toolbars , bem como colocar e remover itens da Barra de Ferramentas e configurar algumas opções de exibição para esses componentes, como por exemplo, a exibição ou não dos Hints (pequenos textos explicativos) que aparecem nos

instalações de novos componentes, a própria instalação se encarrega de criar as páginas em que esses componentes serão instalados, porém esse fato não invalida a possibilidade do desenvolvedor desejar criar novas páginas dentro da Palete de Componentes de tal forma a organizar a IDE do Delphi à sua própria forma de programar. Uma das maneiras pela qual podemos configurar a Paleta de Componentes é através do menu popup por ela exibido como mostrado a seguir. Através desse menu popup, temos a opção de permitir ou não a exibição de Hints (dicas contendo o nome de cada um dos componentes) para os componentes da Paleta da mesma maneira como visto com a Barra de Ferramentas, além da possibilidade de ocultar a própria Paleta de Componentes. Essa última opção já havia sido mencionada anteriormente quando vimos o menu popup da Barra de Ferramentas. Existe ainda a possibilidade de solicitarmos o apoio do Help. A utilização do Help é um ponto que devemos sempre ressaltar por se tratar de uma fonte muito importante de informação, talvez não tanto com relação ao menu popup mostrado aqui mas em diversos outro pontos principalmente como auxílio à própria programação. Dentre os itens do menu popup mostrado ao lado, sem dúvida alguma a que mais irá nos interessar é a opção que nos permite alterar as propriedades da Paleta de Componentes. Essa opção também pode ser selecionada através da opção Configure Pallete , localizada no menu Component. A caixa de diálogo Pallete Properties , mostrada ao lado, permite que o desenvolvedor configure a Paleta de Componentes de acordo com as suas necessidades e preferências. O desenvolvedor poderá criar novas guias para conter tanto novos componentes quanto para redistribuir aqueles já existentes, através de uma simples operação de Drag and Drop entre as guias de origem e destino. Além disso, o desenvolvedor poderá remover e renomear as guias já existentes ou, simplesmente, reordenar os componentes em suas respectivas guias. Quando desejarmos remover uma guia deveremos ter cuidado, pois ao selecionarmos o botão Remove , o Delphi não solicita uma confirmação a respeito dessa remoção. Caso desejemos restaurar a configuração original podemos clicar o botão Default Pages , visível apenas quando selecionamos a opção [All] localizada no ListBox Pages. Devemos ainda lembrar que ao redistribuirmos os componentes dentro das guias da Paleta de Componentes estamos alterando a configuração original do Delphi para atender às nossas necessidades. Essa alterações estão sendo feitas apenas em nosso ambiente de trabalho e não estarão disponíveis quando prescisarmos utilizar uma outra instalação para continuarmos o desenvolvimento de nossos aplicativos. O mesmo devemos ter em mente quando utilizamos componentes de terceiros.

2.2. Os Formulários

A grande maioria das aplicações desenvolvidas para o sistema operacional Windows, excetuando-se em alguns casos, por exemplo, as DLLs ou aplicativos desenvolvidos para trabalhar em modo “DOS”, é composta de uma ou mais janelas, também chamadas de formulários. Dessa forma, como não poderia deixar de ser, a grande maioria das aplicações que iremos desenvolver serão compostas de um ou vários formulários. Em aplicações que possuam mais do que um formulário, devemos observar que existirá sempre um formulário responsável pela execução da aplicação. Enquanto esse formulário permanecer “aberto”, nossa aplicação permanecerá em execução. Esse formulário é chamado de formulário principal da aplicação e, devido ao papel

diferenciado que ele exerce sobre a aplicação, deverá receber uma atenção especial por parte dos programadores para o ambiente Windows.

Ao iniciarmos o ambiente de desenvolvimento do Delphi, nos é apresentado um formulário inicial, em geral não contendo qualquer componente como mostrado na figura. Esse formulário inicial é exatamente o formulário principal dessa nova aplicação, porém essa característica do formulário poderá ser alterada posteriormente com o decorrer do

desenvolvimento do aplicativo (veremos como alterar o formulário principal de nossa aplicação posteriormente). Ao darmos início ao processo de desenvolvimento das aplicações iremos colocar em cada formulário os diversos componentes que irão compor tanto a sua interface, como por exemplo, botões e menus, quanto iremos definir os procedimentos a serem executados por cada um desses componentes como, por exemplo, o que será executado quando clicarmos em um determinado item de menu. Todo esse processo é realizado em diversas etapas, todas elas importantíssimas no desenvolvimento de aplicações para o ambiente Windows. A primeira delas é a colocação dos componentes em cada um dos formulários da aplicação. Os componentes podem ser colocados nos formulários de várias maneiras, veremos algumas delas a seguir.

A maneira mais simples de colocarmos um componente em um formulário é darmos um duplo clique sobre o componente desejado na Paleta de Componentes. Por exemplo, caso desejemos colocar um botão, localizado na guia Standard , no formulário podemos dar um duplo clique sobre esse componente. Ao fazermos isso, um botão será colocado no centro do formulário seguindo a largura e altura padrão definidos para um botão.

Embora essa seja a maneira mais simples de colocarmos um componente em um formulário, essa não é a mais usual. Em geral, colocamos os componentes no formulário clicando no componente desejado na Paleta de Componentes e, em seguida, clicando no formulário. Ao fazermos isso, diferentemente do que acontecia anteriormente, o componente é colocado, ainda com largura e altura padrão, no formulário porém não mais na posição central do formulário mas sim na posição aonde o mouse foi clicado. De forma bastante semelhante, podemos colocar um componente definindo uma nova altura e largura. Para isso basta que cliquemos no componente desejado na Paleta de Componentes e, ao clicarmos no formulário permaneçamos com o botão do mouse pressionado, arrastando-o até o tamanho desejado. Existem, no entanto, alguns componentes que não permitem alterar suas dimensões conforme mostraremos mais adiante.

Devemos observar dois pontos importantes com relação aos componentes existentes na Paleta de Componentes. O primeiro deles é que nem todos os componentes que colocamos nos formulários das nossas aplicações serão visíveis aos usuários durante a execução do aplicativo, ou seja, existem dois tipos de componentes: aqueles que são visíveis tanto em tempo de desenvolvimento quanto em tempo de execução e aqueles que só estão visíveis durante o desenvolvimento da aplicação. Esses últimos, chamados de componentes não-visuais não permitem que suas dimensões sejam alteradas. Esse comportamento é perfeitamente compreensível uma vez que esses componentes não serão exibidos no formulário durante a execução da aplicação e por isso não faz sentido podermos dimensioná-los. O segundo ponto a observarmos é que, a cada componente que colocamos no formulário, o Botão de Seleção (aquele com o desenho de uma seta, localizado na Paleta de Componentes) torna-se o botão ativo indicando que podemos manipular com o componente correntemente selecionado.

Uma observação deve ser feita com relação ao dimensionamento dos componentes utilizando-se a caixa de diálogo Size. Apesar de podermos utilizá-la para redimensionar um único componente (para isso podemos utilizar a opção Width e Height ), a caixa de diálogo Size será utilizada com maior freqüência quando estivermos trabalhando com vários componentes simultaneamente.

Para selecionarmos múltiplos componentes devemos clicar no primeiro componente que desejamos manipular selecionando-o assim e, em seguida, mantendo a tecla Shift pressionada, devemos clicar nos demais componentes que serão manipulados. Uma outra forma de selecionarmos múltiplos componentes é através da definição de uma área de abrangência. Para isso, o desenvolvedor deverá clicar com o mouse em uma região do formulário e, em seguida, mantendo o botão primário do mouse pressionado, arrastar o mouse demarcando a área cujos componentes nela contidos deverão ser selecionados. Após a delimitação da área desejada devemos liberar o botão primário do mouse para que, dessa maneira, os componentes sejam marcados como selecionados. Uma vez que tenhamos selecionado os componentes, as opções da caixa de diálogo Size poderão ser aplicadas a eles tanto com relação à altura quanto ao comprimento desses componentes. Uma vez que sabemos como marcar vários componentes resta-nos saber como desmarcá-los, para tanto basta clicarmos em qualquer outro componente que não esteja marcado, tornado assim esse último o componente selecionado.

Além da tarefa de redimensionar os componentes, resta ao desenvolvedor alinhá-los para dar uma melhor aparência ao seu programa. Para isso, da mesma forma como fizemos para redimensionar os componentes colocados no formulário, poderemos simplesmente clicar sobre os componentes selecionando-os e, em seguida, arrastá-los até a posição desejada, ou poderemos utilizar as ferramentas do Delphi para isso.

Em geral, a tarefa de alinhar os componentes no formulário não é tão difícil devido à existência do grid. O grid nada mais é do que os vários pontos existentes nos formulários exibidos na IDE do Delphi. O comportamento default para os componentes é o seu auto-alinhamento em relação aos pontos do grid , ou seja, ao redimensionarmos ou arrastarmos os componentes pelo formulário eles irão sempre se posicionar de acordo com os pontos do grid facilitando, dessa forma, o trabalho do programador. Mesmo assim, existirão situações em que a tarefa não será tão simples como, por exemplo, caso desejemos centralizar alguns componentes no formulário. Apesar de podermos tentar fazer isso de forma “visual”, não será difícil errarmos por uma diferença de um ou dois pontos do grid. Para evitarmos que isso aconteça, poderemos recorrer às ferramentas de alinhamento que o Delphi nos oferece.

A primeira caixa de diálogo que poderemos utilizar para alinhar os componentes é a caixa de diálogo Alignment, mostrada ao lado, obtida através da opção Align selecionada a partir do menu popup exibido ao clicarmos sobre um componente de nosso formulário. Essa caixa de diálogo é bastante semelhante à caixa de diálogo Size mostrada anteriormente. Nela podemos escolher qual o tipo de alinhamento que desejamos aplicar aos componentes selecionados tanto com relação a sua

horizontal quanto a sua vertical. Novamente percebemos que a maioria das opções listadas nessa caixa de diálogo só faz sentido quando aplicadas a mais de um componente.

Porém, muitas vezes, ao invés de alinharmos os componentes através da caixa de diálogo Alignment , o fazemos através de uma outra ferramenta do Delphi, a Alignment Pallete. Para exibirmos a Alignment Pallete devemos escolher a opção de mesmo nome localizada no menu View. Ao fazermos isso nos será exibida a caixa de diálogo mostrada ao lado. A Alignment Pallete possui basicamente as mesmas funcionalidades que a caixa de diálogo Alignment mostrada acima, porém com a diferença de que as opções de alinhamento são exibidas de forma gráfica, o que torna o entendimento da funcionalidade de cada botão muito mais fácil e rápido. Além da exibição gráfica da funcionalidade de cada botão, é exibido um hint para cada um desses botões quando permanecemos com o mouse por sobre eles por um pequeno intervalo de tempo. Vimos até aqui como é fácil colocarmos os componentes nos formulários de nossa aplicação, além das várias maneiras possíveis de como podemos redimensioná-los e alinhá-los. Resta-nos, apenas, mostrar como podemos remover os componentes que não desejamos mais que permaneçam no formulário. Já podemos imaginar até como isso pode ser feito (lembre-se que a programação no ambiente Delphi é bastante intuitiva). Para removermos um ou mais componentes de nosso formulário basta que selecionemos os componentes desejados e, em seguida, pressionemos a tecla Delete ou através da opção Delete localizada no menu Edit. Caso deletemos por engano algum componente não precisamos nos preocupar, as operações de deleção podem ser desfeitas através da opção Undelete localizada no menu Edit ou através de sua tecla de atalho Ctrl + Z.

2.3. O Object Inspector

Uma das principais janelas do ambiente de desenvolvimento Delphi é o Object Inspector. Ele é o principal responsável pela definição das características e do comportamento de cada componente colocado nos formulários da aplicação sendo desenvolvida. Por essa razão, em geral, ele encontra-se sempre visível ao iniciarmos o Delphi. Caso isso não ocorra, para visualizarmos o Object Inspector, a qualquer momento dentro da IDE do Delphi podemos selecionar a opção Object Inspector localizada no menu View ou utilizar sua tecla de atalho F11. O Object Inspector é mostrado na figura ao lado. Como podemos observar, o Object Inspector é composto de duas partes. Um ComboBox contendo a lista de componentes contidos no formulário correntemente selecionado da aplicação, incluindo nesses componentes o próprio formulário. O Object Inspector contém ainda um PageControl composto por duas guias: Properties e Events. Esse ComboBox tem a finalidade de indicar o componente atualmente selecionado no formulário bem como a classe a qual ele pertence (veremos o que são classes posteriormente). Podemos também utilizar esse ComboBox para selecionar um novo componente, para isso basta que selecionemos seu nome dentre os itens que aparecem na lista do ComboBox (veremos mais adiante o que é o nome de um componente). Já o Page Control divide o Object Inspector em duas guias. A primeira delas, chamada Properties , contém as propriedades do componente correntemente selecionado, enquanto que, a segunda guia, chamada Events , possui os eventos disponíveis para esse componente. Quando selecionamos componentes diferentes, ou seja um botão e depois uma caixa de texto por exemplo, as propriedades e eventos apresentados são diferentes, ora as propriedades e eventos pertencentes ao botâo e ora pertencentes à caixas de texto, sempre de acordo com o componente selecionado. Esse fato é muito importante e por isso devemos sempre nos lembrar que o Object Inspector exibirá as propriedades e eventos do componente correntemente selecionado, por isso não citaremos mais essa observação no decorrer de nosso estudo do Delphi. Ora, se o Object Inspector exibe as informações relacionadas ao componente selecionado, o que acontece quando selecionamos dois ou mais componentes simultaneamente? Quando selecionamos múltiplos componentes, o Object

na IDE do Delphi, a prática nos levará a identificar quais são os possíveis valores que podem ser atribuídos a essas propriedades. A cada propriedade está associado um tipo de dados que define quais valores podem ser a atribuídos a cada uma delas. Por exemplo, a propriedade Caption do formulário, citada anteriormente, foi definida como sendo do tipo de dados string (veremos os diversos tipos de dados suportados pelo Delphi posteriormente), podendo receber qualquer conjunto de caracteres. Já a propriedade ClientHeight , também listada na figura anterior, foi definida como sendo do tipo integer podendo receber apenas valores inteiros. Caso tentemos colocar um valor inválido para uma propriedade, o Delphi irá exibir uma mensagem de erro informando que o valor que tentamos inserir não corresponde a um valor válido para aquela propriedade. Na figura ao lado mostramos a mensagem de erro exibida pelo Delphi ao tentarmos colocar o valor ibratec na propriedade Client Height de um formulário. Nesse exemplo, o Delphi nos informa que o valor que colocamos não é um número inteiro válido e, portanto, não deveria ter sido atribuído à propriedade Client Height.

Para facilitar o trabalho do desenvolvedor Delphi, algumas propriedades de tipos mais complexos do que as que permitem strings e inteiros, apresentam os valores válidos em um combo box. Dessa forma, o desenvolvedor precisa apenas selecionar dentre um dos valores listados. É importante observar que os valores listados nos combo boxes são aqueles que podem ser atribuídos à variável sendo manipulada, independentemente se estivermos alterando-a em tempo de desenvolvimento ou em tempo de execução através da codificação do aplicativo sendo desenvolvido. No caso de tentarmos atribuir um valor que não esteja definido para a propriedade, ao tentarmos compilar o nosso aplicativo, o Delphi exibirá uma mensagem de erro informando que estamos tentando atribuir um valor inválido para aquela propriedade, de forma semelhante ao que aconteceu ao tentarmos atribuir um valor inválido dentro do Object Inspector. Um outro ponto importante a observarmos é que esses valores listados dentro do combo box não são strings e portanto, não obedecerão à notação de strings. Essas propriedades são definidas como pertencentes aos chamados tipos enumerados. A notação para a definição e atribuição tanto de strings quanto de tipos enumerados será vista posteriormente.

Como podemos observar na figura acima, o Delphi também possui propriedades simbolizadas com um pequeno sinal de + ao seu lado esquerdo. Esse sinal permite o desmembramento da propriedade listando itens que a compõe. Por exemplo, a propriedade Anchors listada no Object Inspector mostrado na figura anterior, possui um conjunto de valores que podem ser atribuídos a ela. Aqueles valores que desejamos que estejam contidos na propriedade deverão estar com o valor true atribuído, enquanto que aqueles que não desejamos deverão estar com o valor false. No exemplo acima, a propriedade Anchors está definida contendo os valores akLeft e akTop uma vez que a esses valores foi atribuído o valor True. Esses tipos especiais de propriedades, chamados Sets serão vistos posteriormente no decorrer de nosso estudo. Podemos facilmente identificar quais propriedades são Sets uma vez que, no Object Inspector, os valores dessas propriedades aparecem entre colchetes.

Além das propriedades definidas como Sets , um outro conjunto de propriedades apresentam do seu lado esquerdo um sinal de + no Object Inspector. Essas propriedades podem representar tanto Sets quanto Objetos. O desenvolvedor poderá facilmente diferenciar cada uma dessas duas situações através do conteúdo da propriedade em questão. Ao contrário do que acontece com os Sets , que apresentam seu conteúdo

entre colchetes, as propriedade que apresentam seu conteúdo entre sinais de parênteses representam objetos (veremos posteriormente a definição de classes e objetos). Essas propriedades representam novos objetos contidos dentro do componente em questão, que por sua vez também é um objeto. Veremos toda essa idéia de objetos posteriormente, por hora basta termos em mente que podem existir propriedades que representam tanto Sets quanto objetos. A figura anterior mostra a propriedade Font do formulário. Essa propriedade ilustra dois aspectos com relação a propriedades que representam objetos. Podemos observar que a propriedade Font possui, por sua vez, outras propriedades. Ao contrário do que acontecia com os Sets , cujos valores que podíamos atribuir eram apenas True ou False , as propriedades que aparecem abaixo de Font podem receber valores inteiros, strings, Sets ou até mesmo novos objetos. Uma segunda observação está no fato da existência de um botão, ao lado do valor da propriedade Font. Ao clicarmos esse botão será exibida um caixa de diálogo que nos permite preencher de forma mais agradável o valor das propriedades que foram listadas, em nosso exemplo, a propriedade Font. A figura ao lado mostra a caixa de diálogo que é exibida ao clicarmos no botão da propriedade Font. Devemos ter em mente que a caixa de diálogo mostrada não é de exibição obrigatória, ou seja, podem existir propriedades dentro de componentes do Delphi que representem objetos mas que não possuam uma caixa de diálogo para permitir uma definição mais fácil dos valroes de suas propriedades. A existência dessas caixas depende das pessoas que construíram, ou seja, programaram cada um desses componentes. É uma prática de programação bastante comum dentro do ambiente Delphi que, as propriedades de componentes que representem objetos deverm ter uma caixa de diálogo associada mas isso não torna obrigatória a existência dessas caixas de diálogo. Caso estejamos estudando o Delphi para desenvolver novos componentes devemos lembrar que, caso exista um propriedade que contenha um objeto em nosso componente, devemos desenvolver uma caixa de diálogo que permita o preenchimento das informações para esse objeto.

A segunda guia existente no Object Inspector é responsável pela exibição dos Eventos aos quais o componente selecionado pode responder. Esses eventos, da mesma forma como acontecia com as propriedades, são específicos para cada componente, ou seja, podem existir eventos comuns ou não aos diversos componentes existentes no Delphi. A figura ao lado mostra os eventos aos quais um formulário pode responder.

Já sabemos que o Object Inspector, de forma semelhante ao que acontece com as propriedades, exibe os eventos específicos para cada componente selecionado. Porém, para que servem os eventos? Os eventos formam uma das partes mais importantes na programação dentro do ambiente Windows. É através do disparo de eventos que existe a interação entre o usuário e o código escrito em cada programa. Eventos são disparados por ações do usuário ou de outros programas, e esses eventos por sua vez, executam a codificação escrita pelos programadores durante o seu desenvolvimento. No Delphi, a maneira mais simples de associarmos que código que será executado quando cada um desses eventos ocorrer é através do Object Inspector. Por exemplo, caso quiséssemos exibir uma mensagem quando o usuário clicasse no formulário, poderíamos escrever o código responsável pela exibição da mensagem e associá-lo ao disparo do evento OnClick do formulário. Podíamos também efetuar essa associação através da própria codificação porém deixamos a explanação de como isso pode ser feita para uma discussão um pouco mais avançada dentro do Delphi. A guia Events está dividida de forma semelhante à guia Properties. Do lado esquerdo estão listados os nomes dos eventos enquanto que do lado direito está o nome de qual trecho de código deverá ser executado quando o evento em questão for disparado. Com o intuito de facilitar o trabalho do desenvolvedor, o nome de cada evento segue um padrão de nomenclatura, observe que dentro do Object Inspector cada evento tem seu nome composto do prefixo On mais o evento que irá dispará-lo.