Programando com C++Builder

[helldanger1]

Usando componentes







Muitos componentes visuais são fornecidos prontos no Componente palette do ambiente de desenvolvimento integrado (IDE). Selecionamos o componente na pallete e o arrastamos para o form, a fim de desenharmos a interface da aplicação. Somente os componente visuais podem ter posição, tamanho e outras propriedades ajustadas no form.

Os Componentes do C++Builder são agrupados em diferentes páginas do Componente pallete de acordo com suas funcionalidades. Por exemplo, componentes usualmente usados para criar menus, edit boxes ou buttons estão localizados na página Standard do Component palette. Controles úteis como timer, paint box, media player, e OLE container estão na página System.



Num primeiro momento, os componentes C++Builder parecem exatamente como qualquer outra classe C++. Mas há diferenças entre componentes C++Builder e as hierarquias de classe standard C++ que a maioria dos programadores C++ trabalha. Algumas dessas diferenças são:



Todos os componentes C++Builder descendem de Tcomponent.



Componentes são freqüentemente usados tal como são, e muitas vezes servem de “classes base” para subclasses quando têm suas funcionalidades alteradas através de sua propriedades. Quando um componente é herdado, ele freqüentemente adiciona um código específico em um evento existente ou função-membro.



Componentes VCL somente podem ser alocados no heap, mas não na stack (isto é, eles precisam ser criados com o operador new).



Propriedades intrínsecas dos componentes possuem informações típicas em tempo de execução.



Componentes podem ser adicionados ao Componente palette do C++Builder e manipulados no form.



Componentes freqüentemente alcançam (executam) um melhor grau de encapsulamento que são usualmente encontrados nas classes standard C++. Por exemplo, considere o uso de um diálogo contendo um botão de pressão. Num programa C++ Windows, quando o usuário clicar o botão, o sistema gera uma mensagem WM_LBUTTONDOWN. O programa deve capturar esta mensagem (tipicamente uma instrução, uma mensagem, ou uma resposta) e enviá-la para a rotina que deve executar a resposta à mensagem.



A maioria das mensagens Windows são cuidadas pelos componentes C++Builder. Quando desejamos uma resposta para uma mensagem Windows, só precisamos providenciar um evento handler.

 

[helldanger1]

VCL standard componentes





O componente pallete contém uma seleção de componentes que permitem realizar grande variedade de programações. Podemos adicionar, remover, e reordenar os componentes na pallete, e criar componentes, modelos e frames que agruparão muitos componentes.



Os componentes são arrumados na pallete de acordo com suas finalidades e funcionalidades. Essas páginas, de acordo com a versão do C++ Builder que estiver rodando, contém uma arrumação padrão. A lista a seguir enumera as páginas padrão e os tipos de componentes nelas contidos.





Standard - Controles padão Windows.



Additional - Controles adicionais



Win32 - Controles comuns Windows 9x/NT 4.0



System - Componentes e controles para acesso aos sistema, incluindo timers, multimedia, e DDE



Data Access - Componentes não visuais para accessar database tables, queries, and reports



Data Controls - Componentes visuais, controles data-aware



ADO - Componentes que provêem acesso a dados através de sistema ADO



InterBase - Componentes que fornecem acesso direto a InterBase



Midas - Componentes usados para criar aplicações base de dados multi-tiered



Internet Express - Componentes que são simultaneamente uma aplicação Web Server e o cliente de uma aplicação base de dados multi-tiered



Internet - Componentes para comunicação de protocolos de Internet e aplicações Web



FastNet - Controles Internet NetMasters



Decision Cube - Controles que permitem você resumir informações de base de dados e visualizá-las de uma variedade de perspectivas



Qreport - Componentes QuickReport para criação de relatórios



Dialogs - Caixas comuns de diálogo Windows



Win 3.1 - Componentes no velho estilo Win 3.1



Samples - Componentes Sample custom



ActiveX - Controles Sample ActiveX



Servers - COM Servers para Microsoft Excel, Word, e assim por diante



O help online fornece informações acerca dos componentes na guia padrão. Alguns dos componentes como ActiveX e Samples são apenas providos de exemplos, não havendo qualquer documentação sobre os mesmos.

 

[helldanger1]

Controles de Texto







Muitas aplicações apresentam texto para o usuário ou para permitir que o usuário entre com seu próprio texto. O tipo de controle usado para este propósito depende do tamanho e do formato da informação.




Use este componente
Quando desejar este resultado

Edit
Editar uma única linha de texto

Memo
Editar múltipla linhas de texto

MaskEdit
Editar a um formato particular, como caixa postal ou número de telefone

RichEdit
Editar múltiplas linhas de texto usando formato rich text, ou seja, linhas passíveis de formatação






Propriedades de texto





Eis um grupo de propriedades:


Text
determina o texto que aparece no edit box ou controle memo.

CharCase
força o o texto entrar como lowercase (minúsculas) ou uppercase (maiúsculas).

ReadOnly
(somente leitura) especifica se o usuário está autorizado a entrar com o texto, ou alterá-lo.

MaxLength
limite do número de caracteres no controle.

PasswordChar
oculta o texto, exibindo somente um único caractere (normalmente um asterisco).

HideSelection
especifica se o texto selecionado fica destacado quando o controle não possui o foco.

 

[helldanger1]

Mais Propriedades de texto





Controles Memo e RichEdit, que trabalham com múltiplas linhas de texto, possuem várias propriedades em comum; outras pertencem ao Edit (controle de uma linha):


Alignment
especifica como o texto é alinhado no componente (left (esquerda), right (direita), ou center (centro)).

Text
A propriedade Text pertence ao controle. Sua aplicação pode saber se o texto foi alterado pela checagem da propriedade Modified.

Lines
contém o texto como uma lista de strings.

OEMConvert
determina se o texto está temporariamente convertido de ANSI para OEM como é colocado. Isto é proveitoso para validade file names.

WordWrap
determina se o texto passará para a próxima linha quando alcançar a margem direita.

WantReturns
determina se o usuário pode inserir returns (tecla Enter) no texto.

WantTabs
determina se o usuário pode inserir tabs no texto.

AutoSelect
determina se o texto será automaticamente selecionado quando o controle se tornar ativo.

SelText
contém a parte selecionada do texto.

SelStart e SelLength
indica a posição e comprimento (length) da parte selecionada do texto.



Em tempo de execução, você pode selecionar todo o texto

em um memo com o método SelectAll








Controles Rich text







O Componente Richedit é um controle memo que suporta formatação rich text, impressão, localização e arrastar e soltar partes do texto. Ele permite que nós especifiquemos propriedades das fontes, alinhamento, tabs, margem e numeração.

 

[helldanger1]

Controles Splitter







Um splitter colocado entre controles alinhados permite ao usuário mudar o tamanho dos controles. Usado com componentes como panels e group boxes, splitters permite-nos dividir um form em várias partes com múltiplos controles em cada parte.

Depois de instalar um panel ou outro controle no form, adicione um splitter com o mesmo alinhamento daquele. O último controle deverá ser client-alinhado, de forma que preencha o resto do espaço quando o outro tiver seu tamanho alterado. Por exemplo, você pode colocar um panel na margem esquerda do form, assinalando o seu Alignment para alLeft, então ponha um splitter (também alinhado para alLeft) para a direita do panel, e finalmente coloque outro panel (alinhado para alLeft ou alClient) à direita do splitter.



Trabalhe MinSize para especificar um tamanho mínimo para o splitter deixar quando alterado o tamanho do controle vizinho. Marque Beveled para true para dar ao splitter’s uma margem com visual 3D.

 

[helldanger1]

Buttons e controles similares







Ao lado dos menus, os botões provêem o mais comum meio de invocar um comando em uma aplicação. C++Builder oferece vários tipos de controles botões:




Componente
Finalidade

Button
Oferece escolha entre botões com texto

BitBtn
Oferece escolha entre botões com textos e figuras

SpeedButton
Criar um grupo de botões em uma seqüencia

CheckBox
Oferece opções on/off

RadioButton
Oferece um grupo de múltiplas e exclusivas escolhas

ToolBar
Organiza uma ferramenta de botões e outros controles e automaticamente os ajusta

CoolBar
Exibe uma coleção de controles em janelas internas e móveis, ajusta os tamanhos e bandas








Controles Button







O usuário clica botões para iniciar ações. Um duplo clique num botão, em tempo de projeto, determinará a chamada do Editor de Códigos para o evento OnClick.



Devemos colocar Cancel para true quando quisermos que o envento OnClick do botão seja acionado quando o usuário pressionar Esc.

Devemos colocar Default para true quando quisermos que a tecla Enter dispare o evento OnClick dos botões.

 

[helldanger1]

Bitmap buttons







Um botão bitmap (BitBtn) é um botão que apresenta uma imagem bitmap em sua face.



Para escolher um bitmap para o botão, use a propriedade Glyph.

Usamos Kind para configurar um botão automaticamente com uma figura e comportamento padrão.

Por padrão, a figura fica do lado esquerdo de qualquer texto. Para movê-la, usamos a propriedade Layout.

A imagem e o texto são automaticamente centralizados no botão. Para alterar essa condição, usamos a propriedade Margin. Margin determina o número de pixels entre a margem da imagem e a margem do botão.



Por padrão, a imagem e o texto são separados por 4 pixels. Use Spacing para aumentar ou diminuir essa distância.

Botões bitmap podem ter três estados: up (acima), down (abaixado), e held down (permanecer rebaixado). Colocar a propriedade NumGlyphs para 3 para mostrar um diferente bitmap para cada estado.







Speed buttons







Speed buttons, que usualmente possuem imagens em suas faces, podem funcionar em grupos. Geralmente eles são usados com painéis para criar toolbars.



Para fazer um speed buttons atuar como um grupo, coloque a propriedade GroupIndex de todos os botões do grupo para um mesmo valor diferente de zero.

Por padrão, speed buttons aparecem em posição up (estado não-selecionado). Para iniciar exibição de um speed button como selecionado (down) selecione a propriedade Down para true.

Se AllowAllUp estiver true, todos os speed buttons num grupo podem estar não-selecionados. Marque AllowAllUp para false se você quiser um grupo de botões que atuem como um radio group.





Check boxes







Um check box é uma alternativa que apresenta ao usuário duas, ou algumas vezes três, opções.



Ponha Checked para true a fim de fazer o box aparecer assinalado por padrão..

Ponha AllowGrayed para true para conceder ao check box três possibilidades de estado: checked (assinalado), unchecked (não assinalado), e grayed (acinzentado, como se fosse uma semi-marcação).

A propriedade State indica se o box esta checked (cbChecked), unchecked (

cbUnchecked), ou grayed (cbGrayed).







Radio buttons







Radio buttons oferecem um grupo de opções mútuas exclusivas. Podemos usar radio buttons individual ou num componente radio group, o qual dispõe grupos de radio buttons automaticamente. Ver Grouping components para maiores informações.

 

[helldanger1]

Toolbars







Toolbars oferecem um modo fácil de organizar e administrar controles visuais. Podemos pode criar um uma barra de botões com um componente panel e alguns speed buttons, ou simplesmente usar o componente ToolBar. Para criar uma barra através dessa segunda opção, após colocar o Toolbar no Form, dê um clique com o botão direito do mouse sobre esse componente e escolha New Button no menu flutuante a fim adicionar botões no Toolbar; Nesse menu pop-up, também podemos escolher New Separator para inserir separadores entre os botões. O componente ToolBar possui várias vantagens: botões num toolbar mantêm dimensões e espaços uniformes automaticamente; outros controles mantém relativas posições e e dimensões nos mesmos; os controles podem passar automaticamente para o início de uma nova linha quando não couber mais controles horizontalmente; e o ToolBar oferece exibição de opções como transparência, bordas, e espaços separadores para os grupos de controles.







Cool bars







Um Coolbar contém controles filhos que podem ser movidos ou redimensionados de forma independente. Cada controle reside em uma banda individual. O usuário posiciona os controles arrastando e ajustando segurando pelo lado esquerdo de cada band.

O Coolbar requer versão 4.70 ou superior de COMCTL32.DLL (usualmente localizado no diretório Windows\System ou Windows\System32) em tempo de desenho e de execução.



A propriedade Bands guarda uma coleção de objetos TCoolBand. Em tempo de desenvolvimento, você pode adicionar, remover, ou modificar bands com o Bands editor. Para abrir o Bands editor, selecione a propriedade Bands no Object Inspector e dê um duplo clique na coluna da direita, ou clique o botão ellipsis (...). Você pode também criar bands adicionando novo controle da pallete.



A propriedade FixedOrder determina se usuários podem reordenar as bands.



A propriedade FixedSize determina se as bands mantém nível uniforme.

 

[helldanger1]

Listas







Lists (listas) oferecem aos usuários uma coleção de itens para seleção. Vários componentes exibem listas.




Componente
Finalidade

ListBox
Uma lista de textos strings

CheckListBox
Uma lista com um check box na frente de cada item

ComboBox
Um edit box com uma lista deslizante drop-down

TreeView
Uma lista hierárquica

ListView
Uma lista de itens com ícones opcionais, colunas e títulos

DateTimePicker
Uma caixa de listas para entrada de datas ou horas

MonthCalendar
Um calendário para selecionar datas




Use os componente não visuais TStringList e TImageList para administrar grupos de strings e imagens. Para maiores informações acerca de string lists, veja Working with string lists.







List boxes e check-list boxes







List boxes e check-list boxes exibem uma lista que os usuários podem selecionar itens.




Items
usa um objeto TStrings para preencher o controle com valores.

ItemIndex
indica qual item na lista está selecionado.

MultiSelect
especifica se um usuário pode selecionar mais de um item ao mesmo tempo.

Sorted
determina se a lista é arrumada em ordem alfabética.

Columns
especifica o número de colunas no controle.

IntegralHeight
especifica se o list box exibe somente entradas que combina completamente no espaço vertical.

ItemHeight
especifica a altura de cada item, em pixels. A propriedade Style pode motivar que a propriedade ItemHeight seja ignorada.

Style
A propriedade Style determina como um controle list exibe seu item. Por default, os items são exibidos como strings. Por alterar o valor de Style, você pode criar owner-draw list boxes que exibem items graficamente ou de outras formas.




Para informações sobre owner-draw controls, veja Adding graphics to controls.

 

[helldanger1]

Combo boxes







Um combo box combina um edit box com uma lista scrollable. Quando o usuário entra com dados no controle - por imprimir ou selecionar da lista - o valor da propriedade Text muda.


Style
Use a propriedade Style para selecionar o tipo de combo box que você necessita.

csDropDown
Use csDropDown se você quiser um edit box com uma lista drop-down.

csDropDownList
Use csDropDownList para fazer um edit box somente leitura (forçando usuários a escolher da lista).

DropDownCount
Marque a propriedade DropDownCount para mudar o número máximo de items exibido na lista.

csSimple
Use csSimple para criar um combo box com uma lista fixa que não fecha. É claro que para redimensionar o combo box assim que a lista de items for exibida.

CsOwnerDrawFixed ou

csOwnerDrawVariable
Use csOwnerDrawFixed ou csOwnerDrawVariable para criar owner-draw combo boxes que exibam items graficamente ou em alturas variáveis.




Para informações sobre controles owner-draw, veja Adding graphics to controls.

 

[helldanger1]

Tree views







Um tree view exibe items num desenho afastado das margens. O controle provê botões que permitem pontos (node – cruzamentos) para ser expandidos e encolhidos. Pode-se incluir ícones com items, rótulos de texto e exibir diferentes ícones para indicar se o ponto está expandido ou retraído. Você ainda pode incluir gráficos, como check boxes, que refletem informações acerca do estado dos items.


Indent
Coloca o número de pixels horizontalmente separando items de seus parents.

ShowButtons
ativa a exibição de botões '+' e '–' para indicar se um item pode ser expandido.

ShowLines
ativa exibição de linhas interligadas para exibir a hierarquia dos relacionamentos.

ShowRoot
determina se linhas interligadas um item top-level está exibido.






Para adicionar items a um controle tree view em tempo de projeto, devemos dar um duplo clique no controle para exibir o TreeView Items editor. Os items adicionados se tornam o valor da propriedade Items. Pode-se mudar os items em tempo de desenvolvimento usando os métodos da propriedade Items, o qual é um objeto do tipo TTreeNodes. TTreeNodes possui métodos para adicionar, deletar, e navegar os itens num tree view.







List views







List views exibe listas em vários formatos.



Use a propriedade ViewStyle para escolher a espécie de lista que você quer:


vsIcon e vsSmallIcon
exibe cada item como um ícone com um rótulo. Usuários podem arrastar items dentro da janela do list view.

vsList
exibem items como ícones rotulados que não podem ser arrastados.

vsReport
exibem ícones em linhas separadas com informações arrumadas em colunas. A coluna da esquerda contém um pequeno ícone e label, e colunas subseqüentes contém subitens especificados pela aplicação.




Use a propriedade ShowColumnHeaders para exibir o cabeçalho das colunas.







Date-time pickers e month calendars







O componente DateTimePicker exibe um list box para entrada de datas ou horas, enquanto o componente MonthCalendar apresenta um calendário para entrada de datas ou ordem de datas. Para usar esses componentes, você deve possuir a versão 4.70 ou superior de COMCTL32.DLL (geralmente localizada no diretório Windows\System ou Windows\System32) tanto em tempo de projeto, quanto em tempo de execução.

 

[helldanger1]

Componentes para Agrupamento







Uma interface gráfica é facilmente utilizada quando controles parentes são apresentados em grupo. C++Builder provê vários componentes para agrupar componentes:




Component
Finalidade

GroupBox
Um group box padrão com título

RadioGroup
Um grupo simples de radio buttons

Panel
Um grupo visual, mais flexível, de controles

ScrollBox
Uma região com barras deslizantes para controles

TabControl
Um grupo de múltiplas e exclusivas tabs estilo agenda

PageControl
Um grupo de múltiplas e exclusivas tabs estilo agenda com páginas correspondentes, cada uma das quais podendo conter diferentes controles

HeaderControl
Para prover títulos para colunas de dados








Group boxes e radio groups







Um group box é um componente janela padrão que organiza controles parentes no form. O grupo de componentes mais usados geralmente são os radio buttons. Depois de instalar um group box no form, selecione componentes no Componente Pallete e coloque-os no group box. A propriedade Caption contém o texto que rotula o group box em tempo de execução.

O componente radio group simplifica a tarefa de recolher radio buttons e fazê-los trabalhar juntos. Para adicionar radio buttons em um radio group, edite a propriedade Items no Object Inspector; cada string nessa propriedade faz um radio button aparecer no group box com a string como seu caption. O valor da propriedade ItemIndex determina qual radio button está atualmente selecionado. Podemos dispor os radio buttons em uma coluna simples ou em uma múltipla coluna ajustando o valor da propriedade Columns. A respeito dos botões, redimensione o componente radio group.





Panels







O componente panel (painel) provê um container genérico para outros controles. Panels podem ser alinhados com o form para manter o mesmo posicionamento relativo quando o form é redimensionado. A propriedade BorderWidth determina o width, em pixels, da borda em volta de um panel.





Scroll boxes







Scroll boxes criam áreas scrolling (barras deslizantes que aumentam o tamanho do componente) dentro de um form. Aplicações freqüentemente precisam exibir maiores informações do que as que cabem na área especificada. Alguns controles - como list boxes, memos, e forms - podem scroll (adaptar o tamanho colocando barras) seu conteúdo automaticamente. Scroll boxes permitem-nos flexibilidade adicional para definir barras deslizantes arbitrariamente em outras sub-regiões de um form.

Como panels e group boxes, scroll boxes contém outros controles. Mas um scroll box é, normalmente, invisível. Se um controle num scroll box não pode encaixar-se na área visível, o scroll box automaticamente exibe scroll bars (barras deslizantes).







Tab controls







O componente tab control aparenta-se com um divisor de agenda. Você pode criar tabs editando a propriedade Tabs no Object Inspector; cada string na propriedade Tabs representa uma tab. Uma tab control é um painel simples com um grupo de componentes. Para mudar a aparência do controle quando as tabs são clicadas, você precisa escrever um processo na evento OnChange. Para criar páginas múltiplas, prefira usar um page control.





Page controls







O componente page control é um grupo de páginas adequadas para multi-páginas dialogo boxes. Para criar uma nova página em page control, dê um clique com o botão direito do mouse no controle e escolha New Page.







Header controls







Um header control é um grupo de colunas headers que o usuário pode selecionar ou redimensionar em tempo de execução. Edite a propriedade Sections para adicionar ou modificar headers.

 

[helldanger1]

Componentes de efeitos Visuais





Há muitas maneiras de prover os usuários com informações a respeito do estado de uma aplicação. Por exemplo, alguns componentes - incluindo TForm - possuem a propriedade Caption que pode ser ajustada em tempo de execução. Você também pode criar caixas de diálogo para exibir mensagens. Em adição, os seguintes componentes são especialmente usados para prover feedback visual em tempo de execução.




Componente
Finalidade

Label e StaticText
Exibe um texto não editável

StatusBar
Exibe uma região status (freqüentemente na parte de baixo de uma janela)

ProgressBar
Exibe a quantia de trabalho que já se encontra efetuado de uma tarefa específica

Hint e ShowHint
Atvia um fly-by ou “tooltip” help

HelpContext e HelpFile
Link contexto-sensitivo Help online








Componentes Label e StaticText





Labels exibem textos e são usualmente colocados próximo a outros controles. O componente label standard, TLabel, é um controle non-windowed (não provido de janelas), e portanto ele não pode receber o foco; quando você necessitar de um label com uma janela handle, use TStaticText no lugar de TLabel. Label inclui as seguinte propriedades:




Caption
contém a string de texto para o label.

FocusControl
liga o label com outro controle no form. Se Caption incluir uma tecla aceleradora (atalho), o controle especificado por FocusControl recebe o foco quando o usuário pressionar a tecla aceleradora.

ShowAccelChar
determina se o label pode exibir um caracter acelerador sublinhado. Se ShowAccelChar é true, qualquer caracter precedido por um ampersand (&) aparece sublinhado e ativada a tecla aceleradora.

Transparent
determina se itens abaixo de label (como gráficos) são visíveis.










StatusBar





Embora você possa usar um panel para criar um status bar, é mais simples usar o componente StatusBar. Por default, a propriedade Align dos status bar’s é setada para alBottom, a qual cuida tanto da posição quanto do tamanho.

Se queremos somente exibir um texto no status bar, devemos marcar a propriedade SimplePanel para true e a propriedade SimpleText para controlar o texto exibido no status bar.

Também podemos dividir um status bar em várias áreas de texto, chamando a propriedade Panels. Para criar Panels editamos a propriedade Panels no Object Inspector, setando cada Panels individualmente no Panels Editor, e tratando das propriedades Width, Alignment, e Text, no Object Inspector. Cada propriedade Text contém o texto exibido no Panels.

 

[helldanger1]

ProgressBar



Quando a aplicação executa alguma operação que consome algum tempo, podemos usar um progress bar para mostrar quanto da tarefa já se encontra completada. Um progress bar exibe uma linha pontilhada que progride da esquerda para a direita.

A propriedade Position segue o comprimento da linha pontilhada. Max e Min determina a ordem da Position. Para fazer uma linha crescer, incremente Position pela chamada do método StepBy ou StepIt. A propriedade Step determina o incremento usado por StepIt.







Propriedades Help e Hint







A maioria dos controles visuais podem exibir contexto sensitivo Help em tempo de execução. As propriedades HelpContext e HelpFile estabelecem um Help contexto numerado e Help file para o controle.

A propriedade Hint contém o texto que aparece quando o usuário move o ponteiro do mouse sobre um controle ou menu. Para ativar hints, devemos marcar a propriedades ShowHint para true; setar ParentShowHint para true determina que a propriedade ShowHint tenha o mesmo valor de seus parents.

 

[helldanger1]

Grids







Grids exibem informações em linhas e colunas. Se você estiver escrevendo uma aplicação banco de dados, use o componente TDBGrid ou TDBCtrlGrid descrito em "Using data controls”. Ou então, use um standard draw grid ou string grid.





Draw grids







Um draw grid (TDrawGrid) exibe dados arbitrários arrumados em tabelas. Para preencher as células do grid, escrevemos um tratamento de evento OnDrawCell.



O método CellRect retorna as coordenadas da tela de uma célula especificada, enquanto o método MouseToCell retorna a coluna e a linha de uma célula em especificadas coordenadas de tela. A propriedade Selection indica o limite da célula selecionada.



A propriedade TopRow determina qual linha está atualmente no topo do grid. A propriedade LeftCol determina a primeira coluna visível na esquerda. VisibleColCount e VisibleRowCount são os números de colunas e linha visíveis no grid.



Você pode alterar o width (largura) ou height (altura) de uma coluna ou linha por meio das propriedades ColWidths e RowHeights. Marque o width do grid lines com a propriedade GridLineWidth. Adicione scroll bars para o grid através da propriedade ScrollBars.



Você pode optar para ter colunas e linha fixed (fixo) ou não-scrolling através das propriedades FixedCols e FixedRows. Determine uma cor fixa para colunas e linhas com a propriedade FixedColor.



As propriedades Options, DefaultColWidth e DefaultRowHeight também afetam a aparência e o comportamento do grid.

String grids







O componente string grid é um descendente de TDrawGrid que adiciona funcionalidades especializadas para simplificar a exibição de strings. A propriedade Cells lista as strings para cada célula no grid; a propriedade Objects lista objetos associados com cada string. Todas as strings e objetos associados para uma coluna ou linha específica pode ser acessada através das propriedades Cols ou Rows.

 

[helldanger1]

Exibições gráficas







Os seguintes componentes conseguem facilmente incorporar gráficos dentro de uma aplicação.


Componente
Para exibir:

Image
Arquivos gráficos

Shape
Formas geométricas

Bevel
Linhas 3D e frames

PaintBox
Gráficos desenhados em seu programa em tempo de execução

Animate
Arquivos AVI






Images







O componente image exibe uma imagem gráfica, como um bitmap, ícone, ou metafile. A propriedade Picture determina o gráfico para ser exibido. Use Center, AutoSize, Stretch, e Transparent como um grupo de opções de exibição. Para mais informações, veja Overview de graphics programming.









Shapes







O componente shape exibe uma forma geométrica. Ele é um controle nonwindowed (não provido de janelas) e não aceita entrada de comandos do usuário. A propriedade Shape determina qual forma o controle assume (retangular, redondo, elíptico etc). Para mudar a cor da forma ou adicionar um padrão de desenho de fundo, use a propriedade Brush, a qual organiza um objeto TBrush. Como o shape é pintado, depende das propriedades Color e Style de TBrush.







Bevels







O componente bevel é uma linha que pode mostrar-se em relevo ou rebaixada. Alguns componentes, como TPanel, possuem propriedades embutidas para criar bordas chanfradas. Quando essas propriedades não estiverem disponíveis, use TBevel para criar cortornos chanfrados, boxes, ou frames. A opção bsLowered de Style determinada bordas rebaixadas e bsRaised, em relevo. Quanto aos possíveis estilos de linhas, o BCB fornece as opções bsBottomLine, bsBox, bsFrame, bsLeftLine, bsRightLine, bsSpacer e bsTopLine na propriedade Shape.





Paint boxes







O paint box permite que você desenhe no form em sua aplicação. Compor um evento OnPaint para desenhar uma imagem diretamente no paint box's Canvas. Desenho fora do limite do paint box é impedido. Para maiores informações, veja Overview de graphics programming.







Controles Animation







Animation é uma janela que silenciosamente exibe um clip Audio Video Interleaved (AVI). Um clip AVI é uma série de quadros bitmap, como um filme. Embora clips AVI possam ter sons, controles animation trabalham somente com clips AVI silenciosos. Os arquivos que você usa devem ser arquivos AVI não comprimidos ou clips AVI comprimidos usando run-length encoding (RLE). Estas são algumas das propriedades de um componente animation:



ResHandle é o handle para o módulo que contém os clips AVI como um recurso. Marque ResHandle em tempo de execução para instância handle ou módulo handle do módulo que inclui os recursos animation. Depois de ajustar ResHandle, marque a propriedade ResID ou ResName para especificar qual recurso no módulo indicado é o clip AVI que deve ser exibido pelo controle animation.



Marque AutoSize para true para que o controle animation ajuste seu tamanho para o tamanho dos quadros no clip AVI.



StartFrame e StopFrame especificam em quais quadros se iniciam e terminam o clip.



Marque CommonAVI para exibir um dos clips comuns Windows AVI providos em Shell32.DLL.



Especifique o início e a interrupção da animação setando a propriedade Active para true e false, respectivamente, e quantas repetições representadas por setar a propriedade Repetitions.



A propriedade Timers permite que você exiba os quadros usando um timer. Isto é útil para sincronizar a seqüência da animação com outras ações, como tocar um som.

 

[helldanger1]

Caixas de diálogos comuns Windows







Os componentes dialog box na página Dialogs do Componente palette cria as caixas de diálogo comuns Windows disponíveis para sua aplicação. Essas caixas de diálogo provêem a todas as aplicações baseadas em Windows uma interface familiar e consistente que capacita aos usuários executar operações com arquivos comuns como abrir, salvar e imprimir arquivos.



Cada caixa de diálogo comum se abre quando o seu método Execute é chamado. Execute retorna um Boolean value (valor booleano): se o usuário escolher OK com o intuito de aceitar alguma mudança realizada pela caixa de diálogo, Execute retorna true; Se o usuário escolher Cancel para escapar da caixa de diálogo sem fazer ou salvar mudanças, Execute retorna false.







Usando as Caixas de Diálogos Comuns







Um componente dialog box geralmente usado é TOpenDialog. Este componente é geralmente chamado por um menu item Novo ou Abrir abaixo da opção Arquivo no menu principal na barra de menus do form.



O componente TOpenDialog cria uma caixa de diálogo Abrir disponível para sua aplicação. O propósito destas caixas de diálogo e o de permitir ao usuário especificar um arquivo para abrir. Você deve usar o método Execute para exibir a caixa de diálogo.

Quando o usuário escolhe OK na caixa de diálogo, o arquivo requerido é armazenado na propriedade FileName de TOpenDialog, o qual você pode então processar como quiser.



O seguinte pedaço de código pode ser instalado em um Action e ligado de acordo com a propriedade Action de um subitem TMainMenu ou ser instalado no evento OnClick de algum subitem:




{
If(OpenDialog1->Execute())
{
filename = OpenDialog1->FileName;
}
}

Este código pode exibir a caixa de diálogo e se o usuário pressionar o botão OK, ele copia o nome do arquivo em uma previamente declarada variável AnsiString nomeada filename.

 

[helldanger1]

Usando objetos auxiliares







A VCL inclui uma variedade de objetos não visuais que simplificam tarefas comuns de programação. Os tópicos seguintes descrevem alguns objetos auxiliares que deixam fáceis a execução das seguintes tarefas:




Trabalho com listas

Trabalho com string lists

Mudar o registro do Windows e arquivos .INI

Uso streams

 

[helldanger1]

Trabalhando com lists







Vários objetos VCL fornecem funcionalidade para criar e controlar listas:


TList
mantém uma lista de ponteiros.

TObjectList
mantém uma lista gerente memória de instâncias objetos.

TComponentList
mantém uma lista gerente memória de componentes (isto é, instâncias de classes descendentes de TComponent).

TQueue
mantém uma lista de ponteiros first-in first-out (primeiro a entrar, primeiro a sair).

TStack
Mantém uma lista de ponteiros last-in first-out (último a entrar, último a sair).

TObjectQueue
Mantém uma lista de objetos first-in first-out.

TObjectStack
Mantém uma lista de objetos last-in first-out.

TClassList
mantém uma lista de class types (classes tipos).

TCollection, TOwnedCollection, e TCollectionItem
mantém coleções desenvolvidas de itens definidos de forma especial.

TStringList
mantém uma lista de strings.




Para mais informações acerca desses objetos, veja a VCL Reference no Help.

 

[helldanger1]

Trabalhando com string lists







Aplicações freqüentemente necessitam controlar listas de caracteres strings. Exemplo: incluir itens em um combo box, linhas em um memo, nomes de fonts, e nomes de linhas e colunas num string grid.



A VCL provê uma interface comum para qualquer lista de strings através de um objeto chamado TStrings e seu descendente TStringList. Além disso para prover funcionalidade para manutenção de string lists, esses objetos permitem fácil inter-operacionalidade; por exemplo, você pode editar as linha de um memo (o qual é uma instância de TStrings) e então usar essas linha como itens num combo box (também uma instância de TStrings).



Uma propriedade string list aparece no Object Inspector com TStrings na coluna da direita (exemplo Lines - TString; Items - TString). Dê um duplo clique em TStrings para abrir o String list editor, onde você pode editar, adicionar ou deletar linhas.



Você também pode trabalhar com objetos string list em tempo de execução para realizar tarefas como:



Carregar e salvar string lists;



Criar uma nova string list;



Manipular strings numa lista;



Associar objetos com uma string list;









Carregando e salvando string lists







Objetos string list provêem métodos SaveToFile e LoadFromFile que nos permitem armazenar uma string list num arquivo texto e carregar o arquivo texto para dentro de uma string. Cada linha no arquivo texto corresponde a uma string numa lista. Usando esses métodos, você pode, por exemplo, criar um simples editor de textos para carregar um arquivo em um componente memo, ou salvar listas de itens para combo boxes.

O exemplo a seguir carrega uma cópia do arquivo WIN.INI para dentro de um campo memo e faz uma cópia (backup) chamada WIN.BAK.




void __fastcall EditWinIni()

{
AnsiString FileName = "C:\WINDOWS\WIN.INI"; // marque o nome do arquivo
Form1->Memo1->Lines->LoadFromFile(FileName); // carregue o arquivo
Form1->Memo1->Lines->SaveToFile(ChangeFileExt(FileName, ".BAK")); // salve o backup
}

 

[helldanger1]

Criando uma nova string list







Um string list é, tipicamente, parte de um componente. Mas, de qualquer forma, há horas em que é conveniente criar string lists independentes, por exemplo para armazenar strings para uma tabela look up. O caminho para você criar e gerenciar um string list depende se a lista é para período curto de prazo (construída, usada e destruída numa simples rotina) ou longo período (disponível até que a aplicação feche). Dependendo do tipo de sring list que você criar, lembre-se que você é responsável por liberar a lista quando você terminar com ela (liberar a memória).



Lista para período curto de prazo



Se você usar um string list somente para a duração de uma rotina, você deve criá-la, usá-la e destruí-la totalmente em único local. Este é o caminho seguro para trabalhar com strings lists:


NOTA: Visto que o objeto string list aloca memória para si e para suas strings, você deve usar um bloco try...__finally para assegurar que a memória é liberada mesmo se ocorrer uma exceção.




1 - Construir o objeto string-list.



2 - Na parte tentativa de um bloco try...__finally, use a string list.



3 - Na parte final __finally, libere o objeto string-list.



O seguinte evento handler responde a um clique de um botão para construir uma string list, usá-la, e então destruí-la.




void __fastcall TForm1::ButtonClick1(TObject *Sender)

{
TStringList *TempList = new TStringList; // declare a lista
Try
{
//use o string list
}

__finally
{
delete TempList; // destrói o objeto list
}
}




String lists para longo período



Se uma string list precisa estar disponível por mais tempo enquanto sua aplicação executa, construir a lista no início da aplicação (start-up) e destruí-la antes de a aplicação terminar.



1 No arquivo Unit para o form principal de sua aplicação, adicione um campo do tipo TStrings para a declaração do form.



2 Escreva um evento handler para o construtor de form principal, o qual executa antes de o form aparecer. Ele deve criar um string list e designá-lo para o campo que você declarou no primeiro passo.



3 Escreva um evento handler que libera o pelo evento OnDestroy do form.



Este exemplo usa um string list de longo período para gravar os cliques no mouse do usuário no form principal, então salva a lista em um arquivo antes de a aplicação terminar.




//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
ClickList = new TStringList;
}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
{
ClickList->SaveToFile(ChangeFileExt(Application->ExeName, ".LOG")); //Salve a lista
delete ClickList;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormMouseDown(TObject *Sender, TMouseButton Button,
TShiftState Shift, int X, int Y)
{
TVarRec v[] = {X,Y};
ClickList->Add(Format("Click at (%d, %d)",v,ARRAYSIZE(v) - 1)); //adicione um string para a lista
}

 

[helldanger1]

Manipulando strings numa lista







Operações que geralmente executam uma string lists incluem:


Conta as strings numa lista;

Acesso a uma string particular;

Busca a posição de uma string em uma lista;

Repetir strings numa lista;

Adicionar uma string na lista;

Mover uma string dentro de uma lista;

Deletar um string de uma lista;

Copiar um string list por completo.








Contando a strings numa lista







A propriedade Count retorna o número de strings numa lista. Visto que string lists usam índex base zero (zero-based indexes), Count é um (1) a mais que o índex da última string.







Acessando uma particular string







A propriedade Strings array contém a string na lista, referenciado por um índex base zero. Pelo fato de Strings ser uma propriedade default para string lists, você pode omitir o identificador Strings quando acessar uma lista; desse modo:


StringList1->Strings[0] = "Esta é a primeira string.";



É equivalente a


StringList1[0] = "Esta é a primeira string.";



Usamos Strings para ler ou modificar a string de uma posição em particular. Index contém a posição da string, onde 0 é a posição da primeira string, 1 é a posição da segunda string, e assim por diante. Para localizar uma string em especial na lista, devemos chamar o método IndexOf.







Buscando a posição de uma string numa lista







Para localizar um string numa string list, use o método IndexOf.



IndexOf retorna o índex da primeira string numa lista que compara o parâmetro que lhe foi passado, e retorna - 1 se o parâmetro string não foi encontrado. IndexOf procura somente a exata identidade; Se você quiser identificar strings parciais, você deve procurar através da string list por si mesmo.



Por exemplo, você pode usar IndexOf para determinar se um determinado nome de arquivo encontra-se entre os itens de um list box:



if (FileListBox1->Items->IndexOf("WIN.INI") > -1) ...

 

[helldanger1]

Reiterando através de strings na lista





Para reformar strings numa lista, use um loop for que executa desde zero a Count – 1.

Este exemplo converte cada string de um list box para caracteres maiúsculos.




void __fastcallTForm1::Button1Click(TObject *Sender)

{
for (int i = 0; i < ListBox1->Items->Count; i++)
ListBox1->Items->Strings = UpperCase(ListBox1->Items->Strings);
}







Adicionando uma string a uma lista







Para adicionar uma string ao fim de um string list, chamar o método Add, passando a nova string como parâmetro. Para inserir um string numa lista, chamar o método Insert, passando dois parâmetros: a string e o índex da posição onde você quer que ela seja colocada. Por exemplo, para tornar a string “Three” a terceira string numa lista, você poderia usar:


StringList1->Insert(2, "Three");





Para anexar a string de uma lista em outra, chamar AddStrings:


StringList1->AddStrings(StringList2); // anexa a string de StringList2 em StringList1









Deletando uma string desde uma lista







Para deletar um string de um string list, chamar o método Delete list’s, passando o índex da string que você quer deletar. Se você não sabe o índex da lista que você quer deletar, use o método IndexOf para localizá-lo. Para deletar todas as strings num string list, use o método Clear.



Este exemplo usa IndexOf e Delete para encontrar e deletar uma string:




int BIndex = ListBox1->Items->IndexOf("bureaucracy");

if (BIndex > -1)
ListBox1->Items->Delete(BIndex);







Copiando uma completa string list





Você pode usar o método Assign para copiar strings de uma lista e destiná-la a outra lista, sobrescrevendo o conteúdo da lista de destino. Para anexar strings fora da escrita da lista de destino, use AddStrings. Por exemplo,


Memo1->Lines->Assign(ComboBox1->Item)s; //sobrescreve strings originais



copia as linhas de um combo box em um memo (sobrescrevendo o memo), enquanto


Memo1->Lines->AddStrings(ComboBox1->Items); //anexa strings no fim



anexa as linhas de um combo box no memo.



Quando fizer cópia local de um string list, use o método Assign. Se você determinar um (1) variável string list para outro —


StringList1 = StringList2;



— o objeto string-list original perde-se, freqüentemente com resultados imprevisíveis.







Associando objetos com um string list







Além disso para as strings armazenadas na propriedade Strings, um string list pode manter referências a objetos, o qual armazena em sua propriedade Objects. Assim Strings, Objects são umas array com índex baseado em zero. O uso mais comum para Objects é associação de bitmaps com strings por controles owner-draw (desenho proprietário).



Use o método AddObject ou InsertObject para adicionar uma string e um objeto associado à uma lista em um único passo. IndexOfObject retorna o índex da primeira string na lista associada com um objeto específico. Métodos como Delete, Clear, e Move operam tanto em strings como nos objetos; Por exemplo, deletar uma string remove o objeto correspondente (se havia um).



Para associar um objeto com uma string existente, assinar o objeto para a propriedade Objects em um mesmo índex. Você não pode adicionar um objeto de fora acrescentando a string correspondente.

 

[helldanger1]

Windows registry e INI files







O Windows sistem registro é uma base de dados hierárquica onde aplicações armazenam informação de configuração. A classe VCL TRegistry fornece métodos para ler e escrever o registro.

Até Windows 95, a maioria da aplicações armazenavam informações de configuração em arquivos de inicialização, geralmente nomeados com extensão .INI. A VCL provê as seguintes classes para facilitar a manutenção e migração de programas que usam arquivos INI:



TRegistry para trabalhar com o registro.



TIniFile ou TMemIniFile para trabalhar com Windows 3.x estilo arquivos INI.



TRegistryIniFile quando você quiser trabalhar tanto com o registro quanto com arquivos INI. TRegistryIniFile possui propriedades e métodos similares aos de TIniFile, mas é lido e escrito para o sistem registro. Em usando uma variável do tipo TCustomIniFile (o ancestral comum de TIniFile, TMemIniFile, e TRegistryIniFile), você pode escrever códigos genéricos que acessam um ou outro: o registro ou um arquivo INI, dependendo de onde ele é chamado.







Usando TINIFile







O formato arquivo INI ainda é popular, pois muitas das configurações de arquivos do C++Builder (como o ambiente DSK Desktop) são neste formato. Pelo fato de este formato de arquivo ser e estar predominante, a VCL provê uma classe que realiza leitura e escrita destes arquivos com bastante facilidade. Quando você instanciar o objeto arquivo INI, você passa como um parâmetro para o construtor o nome do arquivo INI. Se o arquivo não existe, ele é criado automaticamente. Então você é livre para ler valores usando ReadString, ReadInteger, ou ReadBool. Alternativamente, se você quiser para ler uma seção completa do arquivo INI, você pode usar o método ReadSection. Similarmente, você pode escrever valores usando WriteBool, WriteInteger, ou WriteString.



A seguir, está um exemplo de leitura configuração informação de um arquivo INI num construtor form's e escrita valor no evento OnClose.




void __fastcall TForm1::TForm1(TObject *Sender)

{

TIniFile *ini;
ini = new TIniFile(
ChangeFileExt( Application->ExeName, ".INI" ) );
Top = ini->ReadInteger( "Form", "Top", 100 );
Left = ini->ReadInteger( "Form", "Left", 100 );
Caption = ini->ReadString( "Form", "Caption",
"Default Caption" );
ini->ReadBool( "Form", "InitMax", false ) ?
WindowState = wsMaximized :
WindowState = wsNormal;
delete ini;

}

void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
{

TIniFile *ini;
ini = new TIniFile(ChangeFileExt( Application->ExeName, ".INI" ) );
ini->WriteInteger( "Form", "Top", Top );
ini->WriteInteger( "Form", "Left", Left );
ini->WriteString ( "Form", "Caption", Caption );
ini->WriteBool ( "Form", "InitMax",
WindowState == wsMaximized );
delete ini;
}




Cada uma das rotinas pega três parâmetros. A primeira seção identifica a seção dos arquivos INI. O segundo parâmetro identifica o valor que você quer para ler, e o terceiro é um valor default para o caso de a seção ou valor não existir no arquivo INI. Similarmente, o escrever rotinas criará a seção valor and/or (e/ou) se eles não existem. O código exemplo cria um arquivo INI que a primeira vez que ele é executado terá um aspecto assim como:


[Form]
Top=185
Left=280
Caption=Default Caption

InitMax=0

Em execução subseqüente desta aplicação, o valor INI será interpretado durante a criação do form e escrito posterior fora no evento OnClose.

 

[helldanger1]

Usando TRegistry







A maioria das aplicações 32 bits armazenam suas informações no registro no lugar de arquivos INI porque o registro é hierárquico, mais robusto e não sofre as limitações de tamanho dos arquivos INI. O objeto TRegistry contém métodos para abrir, fechar, salvar, mover, copiar e deletar chaves.

O seguinte exemplo devolve um valor de uma entrada de registro:




#include <Registry.hpp>

AnsiString GetRegistryValue(AnsiString KeyName)
{

AnsiString S;
TRegistry *Registry = new TRegistry;
try
{
Registry->RootKey = HKEY_LOCAL_MACHINE;
// False porque nós não queremos criá-lo se ele não existe
Registry->OpenKey(KeyName,false);
S = Registry->ReadString("VALUE1");
}
__finally
{
delete Registry;
}
return S;

}









Usando TRegINIFile







Se você está acostumado com arquivos INI e precisa mudar sua configuração para informações sobre registro, você pode usar a classe TRegINIFile. TRegINIFile é desenhado para criar entradas de registro com aparência como entradas arquivos INI. Todos os métodos de TINIFile (leitura e escrita) existem em TRegINIFile. Quando você construir um objeto TRegINIFile, o parâmetro que você passar (o filename para um objeto INIFile) torna-se uma chave. Na realidade, este objeto simplifica consideravelmente a interface do registro, portanto talvez você prefira usá-lo no lugar do componente TRegistry.