Builder ParteI 2016

Lcdo. José F. Guerrero P.
República Bolivariana de Venezuela

Universidad Nacional Experimental del Táchira
Departamento de Ingeniería Informática
Computacion II-Ingeniería Electrónica
San Cristóbal-Venezuela
Tema Perteneciente a la Unidad Nº 2: Programación en C++ Builder.
Autor: Lcdo. José Froilán Guerrero Pulido
Agosto, 2016
Uso del Formulario (TForm)

Las propiedades de un objeto se caracterizan por ser una combinación entre un miembro de
datos y un método. Al tratar una propiedad es como si se tratase de una variable, obteniendo su valor
o modificándolo. Sin embargo, en muchas ocasiones cuando se accede al valor de una propiedad se
estará de manera indirecta provocando la ejecución de un método, cuya finalidad es realizar alguna
acción según la modificación efectuada. Existen ciertas propiedades que solo son accesibles durante
el diseño, mientras que otras solo son accesibles durante la ejecución. Una propiedad además
también puede ser un objeto (se identifican porque al lado izquierdo aparece el signo +) que a su vez
contiene propiedades particulares.
Los eventos son señales internas o externas a la aplicación que el programa aprovecha para
ejecutar cierto bloque de código. Todos los componentes tiene asociado un evento por defecto,
aunque inicialmente es posible crear un método de respuesta distinto para cada evento. Al igual que
ocurre con cualquier función, los métodos de respuesta a eventos también pueden recibir parámetros
de distintos tipos. Un parámetro común a los métodos de respuesta a eventos, que se recibe siempre
en primer lugar, es el llamado Sender, un puntero de tipo TObject. Este parámetro es una referencia a
un objeto, concretamente al objeto que ha dado origen al evento.
A medida que un proyecto se inserten formularios sobre estos se añaden componentes o

controles a los cuales se les asocia eventos. Un formulario puede contener objetos tales como:
TButton, TCheckBox, TComboBox, entre otros. Como se conoce un archivo de C++ se compone al
menos de un archivo de código con el programa principal y por defecto con la función principal
(WinMain), y opcionalmente de una serie de módulos a los cuales es posible alojar funciones y clases
de objetos. Cuando se definen formularios estos son descendientes en principio a un objeto del tipo
TForm. Es posible también crear formularios teniendo como base otros formularios ya existentes, por
lo que el tipo base no será directamente el objeto TForm, aunque éste estará siempre como
ascendiente en algún punto de la jerarquía.
Cuando se parte de un nuevo proyecto observe el nombre asignado por defecto al primer
módulo del proyecto (Unit1.cpp), este módulo incluye los archivos de cabecera necesarios para la
totalidad de las aplicaciones Windows y la definición inicial de un nuevo tipo de objeto, TForm1, que
es derivado del tipo TForm. Ahora, cualquier manipulación sobre el formulario a nivel de componentes
y eventos tiene su reflejo inmediato en el código del módulo asociado al formulario. En el programa
principal a medida que se vayan añadiendo formularios al proyecto se irán insertando líneas con la
macro USERFORM, relacionando todos los módulos de código o formularios con el módulo principal.
Al iniciar el desarrollo de una aplicación en donde existen una serie de formularios de apariencia
común para la entrada de datos y visualización de resultados, esto implica el diseñar una uniformidad
general entre formularios. La idea es comenzar el proyecto diseñando una plantilla que contenga los
aspectos generales de los formularios, hasta incluir código de algunos componentes. Creado y dado
un nombre al formulario que serviría como plantilla, este puede ser usado abriendo el depósito de
objetos y ubicándose sobre la página del proyecto donde se podrá seleccionar el formulario. Si la idea
es heredar los componentes y métodos de la plantilla para un nuevo formulario, se hace necesario
tener en cuenta que la plantilla sea heredada (opción inherit del depósito de objetos), esto implica que
al momento de abrir el archivo DFM (inherited) del nuevo formulario no se observará toda la
información necesaria acerca de los componentes, ya que la información adicional se encuentra en el
archivo DFM del formulario que actúa como plantilla. Lo planteado en este párrafo se conoce como
reutilización de formularios en un mismo proyecto.
Un formulario que ha nacido en una determinada aplicación como base para el desarrollo de
otros formularios más especializados, puede ser útil posteriormente en otros proyectos, sobre todo si
110 Ing. Electrónica
lo que se busca es tener desarrollos comunes entre las aplicaciones informáticas diseñadas. Para
añadir el formulario base al depósito de objetos se debe pulsar el botón derecho del ratón y
seleccionar la opción “Add To Repository”. Luego aparecerá una ventana donde se muestra una lista
con los nombres de todos los formularios del proyecto actual, seleccione el formulario que desea
almacenar en el depósito de objetos y adicione un título, una descripción, el nombre del autor, en que
ficha o página del depósito de objetos se alojará el formulario (escoja la ficha “Forms” como el destino
más lógico del formulario base) y un icono para su representación. A partir de este momento se podrá
usar el formulario siempre que lo desee en cualquier otra aplicación o proyecto.
Además de usar formularios individuales también se puede reutilizar aplicaciones o proyectos

completos. De hecho, en la página “Projects” del depósito de objetos existen varios modelos de
aplicación ya prediseñados. Esta posibilidad esta dirigida sobre todo a reducir el tiempo empleado en
la creación del esqueleto de una aplicación, que suele ser siempre igual. Para añadir un proyecto al
depósito de objetos se abre el menú “Project” y seleccionar la opción “Add To Repository”. Luego
aparecerá una ventana como la descrita en el párrafo anterior. Dado este paso, siempre que se
desee iniciar un nuevo proyecto se puede elegir la página adecuada del depósito de objetos y hacer
doble clic sobre el icono adecuado. Los proyectos que vayan añadirse al depósito de objetos para ser
posteriormente utilizados deberán almacenarse en un directorio que tan solo contenga los elementos
de este proyecto. Al crearse una nueva aplicación tomando como base otro proyecto, C++ Builder
preguntará cuál será el directorio del nuevo proyecto y copiará en él todos los archivos del proyecto
base.
A continuación se definen las propiedades más importantes del componente TForm.
Propiedad Significado
ActiveControl Cuando un formulario tiene diversos componentes el control lo toma uno de ellos, el cual
estará activo al iniciar la aplicación.
HelpContext Asociar al formulario una página de ayuda. Con un valor distinto a cero y presionando la tecla
F1 se activará el archivo de ayuda.
HelpFile Definir la ubicación del archivo de ayuda.
Caption Definir el nombre de la barra de título del formulario.
BorderStyle Cambiar el estilo o la apariencia de los bordes en el formulario. Valores:
bsSizeable = Permite durante la ejecución que el formulario pueda ser redimensionado.
bsSingle = Permite durante la ejecución que el formulario no pueda ser redimensionado.
bsNone = Elimina el borde de la ventana, la barra de título con todos sus controles.
AutoScroll Si el valor de la propiedad es verdadero, las barras del desplazamiento aparecen
automáticamente cuando sea necesario.
HorzScrollBar Editar la barra de desplazamiento horizontal.
VertScrollBar Editar la barra de desplazamiento vertical.
PrintScale Imprimir un formulario mediante la invocación de un método de la clase TForm. Valores:
poNone = No mantener proporción alguna.
poProportional = Imprimir el mismo número de pixels en impresora que en pantalla.
poPrintToFit = Ocupar el mayor espacio posible en la página manteniendo la proporción del
formulario.
Tag Permitir asociar un valor entero al objeto manipulado.
FormStyle Definir el estilo del formulario. Valores:
fsNormal = Corresponde a un formulario independiente sin ventanas internas.

fsMDIForm = El formulario actúa como marco principal para otras ventanas hijas.
fsMDIChild = El formulario actúa como ventana hija dentro de un formulario principal.
fsStayOnTop = El formulario permanece sobre otro sin ser ocultado.
Icon Establecer el icono que aparecerá en la barra de título de la aplicación. Usar el método
LoadFromFile de la clase TIcon.
Cursor Cambiar el cursor que se establece para el área caliente del formulario.
Hint Asignar una cadena de caracteres para la etiqueta de ayuda.
ShowHint Si el valor de la propiedad es verdadero, la etiqueta de ayuda aparece automáticamente
cuando sea necesario.
Visible Si el valor de la propiedad es verdadero, el formulario se hace visible.
Enabled Si el valor de la propiedad es falso, el formulario no estará activo. Esta propiedad trabaja en
conjunto con la propiedad Visible.
Color Seleccionar un color de fondo para el formulario.
BorderIcons Activar/Desactivar los botones de la barra de título del formulario.
Position Cambiar la posición y el tamaño del formulario en pantalla. Valores:
poDesigned = Es el valor por defecto, el formulario aparecerá en la misma posición y tamaño
que se fijó durante el diseño.
poDefault = El formulario cambiará de posición y el tamaño durante cada ejecución.
poDefaultPosOnly = El tamaño del formulario permanece fijo, mientras que la posición va
cambiando en cada ejecución.
poDefaultSizeOnly = La posición del formulario permanece fijo, mientras que el tamaño va
cambiando en cada ejecución.
poScreenCenter = El formulario aparece en el centro de la pantalla conservando el tamaño
dado en el diseño.
Left Define la coordenada horizontal del formulario.
Top Define la coordenada vertical del formulario.
Width Define el ancho del formulario.
Heigth Define la altura del formulario.
WindowsState Determina si el formulario se minimiza, maximiza, o se presenta en su estado normal.
Entre los métodos más usados del componente TForm se especifican los siguientes:
Método Significado
Show Hacer visible un formulario disponiéndola sobre las demás ventanas abiertas.
BringToFront Disponer de un formulario sobre los demás, porque esta activa y oculta en parte.
SendToBack Enviar el formulario al fondo de la pantalla, debajo de las demás ventanas.
Hide Ocultar un formulario de tal forma que no sea accesible por parte del usuario de la aplicación.
Close Cerrar un formulario que no se va a utilizar más en el programa.
Destroy Destruir un formulario al cual no se podrá acceder a sus miembros.
Print Obtener una copia impresa del formulario.
GetFormImage Capturar una imagen del formulario, esta función devolverá un objeto de tipo TBitmap.

En cuanto a los eventos más usados del componente TForm se indican los siguientes:
Evento Significado
OnMouseMove Este es un evento recibido por un componente a medida que el cursor del mouse se mueve
sobre él.
OnMouseDown Se genera cuando se pulsa cualquiera de los botones del mouse, recibiendo este evento
aquel control que en ese momento se encuentra bajo el cursor.
OnMouseUp Cada vez que se libera un botón del mouse sobre el control.
OnClick Denota una pulsación del botón izquierdo del mouse sobre algún control.
OnDblClick Denota doble pulsación (doble clic) del botón izquierdo del mouse sobre algún control.
OnKeyDown Se produce al pulsarse cualquier tecla. Tenga en cuenta que el código recibido no es el
código ASCII, sino el código virtual de la tecla pulsada.
OnKeyUp Este evento se genera al momento de liberar una tecla.
OnKeyPress Se produce al pulsarse cualquier tecla normal, excluyendo teclas de función o edición.
OnDragOver Se produce cuando sobre un determinado control se desplaza un elemento que está siendo
arrastrado.
OnDragDrop Se produce cuando el elemento es soltado sobre el control, liberando el botón izquierdo del
mouse.
OnCreate Se genera cuando el formulario va a ser creado.
OnActivate Este evento se produce en el momento en que el formulario se convierte en la ventana activa
del entorno.
OnShow Antes de que un formulario se haga visible se genera este evento.
OnHide Este evento se produce justo antes de que el formulario sea ocultado.
OnDeactivate Este evento se genera cuando el formulario se vuelve inactivo, porque se ha cambiado a otra
ventana de la aplicación.
OnClose Cuando un formulario ha dejado de ser útil en pantalla.
OnDestroy Cuando un formulario no va a ser utilizado más en el programa después de ocultarse se
destruye.
OnPaint Este evento se genera cada vez que el formulario necesita ser dibujado en pantalla.
OnResize Cada vez que el tamaño de un formulario sea modificado durante la ejecución.
Algunos de los eventos tratados en la tabla anterior son útiles para el comportamiento,
desempeño u ejecución de otros componentes que a continuación se explicaran.
Componentes Receptores de Texto de Uso más Frecuente
TLabel (Standar): Este control permite mostrar texto estático en el formulario, fijando su posición,
color, tipo de letra y tamaño. Suele utilizarse este texto para etiquetar otro control. Al no poseer
formato de ventana no puede recibir entradas desde el teclado. A continuación se definen las
propiedades más importantes del componente TLabel.

Name Toma el nombre que tendrá el componente al momento de hacer referencia de este durante
la programación.
Caption Toma el valor que se mostrará en la etiqueta de texto.
Visible Si el valor de la propiedad es verdadero, la etiqueta se hace visible.
Left y Top Contiene las coordenadas horizontal y vertical del componente.
Width y Height Contiene el ancho y el alto del componente.
AutoSize Si el valor de la propiedad es verdadero, provoca que las dimensiones del componente se
ajusten con exactitud al texto.
Align Controla la alineación del componente en el contenedor que se encuentre. Valores:
alNone = Conserva la posición y dimensiones originales.
alTop = Margen superior del contenedor.
alBottom = Margen inferior del contenedor.
alLeft = Margen izquierdo del contenedor.
alRight = Margen derecho del contenedor.
alClient = Todo el espacio disponible en el contenedor.
Alignment Permite alinear el texto a la izquierda, derecha o centrado.
Font Permite modificar los atributos del texto (Fuente, Color, Tamaño, Estilo y Efectos).
Color Establece un color de fondo para el componente.
Transparent Si el valor de la propiedad es verdadero, provoca que la propiedad no tenga efecto alguno.
FocusControl Permite seleccionar de la lista adjunta el nombre del componente TEdit que corresponda.
Otras propiedades tratadas en el aparte referido al formulario, pueden ser manipuladas en el TLabel, tal es el
caso de: Hint, ShowHint, Enabled, Tag y Cursor.
Entre los métodos más usados del componente TLabel se especifican los siguientes:
Método Significado
Contains Determina si algunos valores constantes se encuentran activos o no en una propiedad.
SetBounds Permite modificar la posición y dimensiones del componente, especificando los valores
correspondientes a las propiedades: Left, Top, Width y Height.
Otros métodos tratados en el aparte referido al formulario, pueden ser manipulados en el Tlabel, tal es el caso
de: BringToFront, SendToBack, Show y Hide.
TEdit (Standar): Este control permite la entrada de datos por teclado. Es un control de texto
desplegable de una sola línea. Se usa para recuperar el texto que los usuarios escriben, pudiendo
servir también para que el usuario visualice el texto que el control recibe, por ejemplo el valor de un
campo de una tabla de una base de datos con la que esté asociado. Muchas de las propiedades de
este componente son comunes al componente TLabel.
Name Toma el nombre que tendrá el componente al momento de hacer referencia de este durante
la programación.
Text Toma el valor que se mostrará en el cuadro de texto inicialmente.

Enabled Si el valor de la propiedad es verdadero, el cuadro de texto estará activo.
Font Permite modificar los atributos del texto (Fuente, Color, Tamaño, Estilo y Efectos).
Color Establece un color de fondo para el componente.
MaxLenght Establece el máximo número de caracteres que se desean admitir en el control. Inicialmente
esta propiedad tiene el valor de cero indicando que en principio no existe un límite.
CharCase Permite convertir las letras introducidas a mayúsculas o a minúsculas. Valores:
ecNormal = No se realiza conversión alguna.
ecLowerCase = Todas las mayúsculas a minúsculas.
ecUpperCase = Todas las minúsculas a mayúsculas.
Modified Determina si el contenido de una celda ha sido modificado o no. El valor de la propiedad por
defecto es falso, por lo cual el usuario al momento de introducir cualquier carácter, la
propiedad tomará el valor de verdadero.
ReadOnly El contenido del campo de texto será de sólo lectura, no modificable por parte del usuario.
PasswordChar Establece que la información introducida por teclado no se refleje en pantalla sustituyendo
cada uno de los caracteres por un cierto símbolo.
SelStart Permite conocer la posición a partir de la cual se ha marcado una porción de texto.
SelLenght Permite conocer la longitud del texto marcado en el componente.
SelText Sirve para obtener el texto que se encuentra seleccionado en el control como para cambiarlo
por otro.
HideSelection Si el valor de la propiedad es verdadero, oculta la selección del texto cuando sale del control.
AutoSelect Si el valor de la propiedad es verdadero, indica al control que cada vez que se active
seleccione todo el contenido o texto.
TabStop Determina si el componente se active mediante la pulsación de la tecla tabulador.
TabOrder Permite establecer un valor numérico para establecer el orden en que se irán activando los
distintos componentes del formulario.
Otras propiedades que pueden ser tratadas en este componente son: BorderStyle, Left, Top, Width, Height,
AutoSize, Hint, ShowHint, Tag y Cursor.
El control TEdit cuenta con un menú contextual específico, el cual no se tiene que crear, ni
gestionar. Otro aspecto importante a destacar es que C++ Builder nos permite establecer el orden de
acceso a los componentes de una forma más cómoda, para ello se tiene la opción “Tab Order” del
menú contextual del formulario, o bien elegir esa misma opción “Edit” del menú principal.
Método Significado
SelectAll Selecciona todo el texto existente en el control.
ClearSelection Elimina el texto seleccionado en ese momento en el control.
CopyToClipboard Copiar el texto seleccionado en el portapapeles.
CutToClipboard Copiar y borrar el texto seleccionado del componente en el portapapeles.
PasteFromClipboard Tomar el texto existente en el portapapeles e insertarlo en la posición que indique el cursor
en el control.
Otros métodos que pueden ser utilizados en este componente son: Show, Hide, BringToFront y SendToBack.

Entre los eventos más significativos de este control se especifican los siguientes:
Evento Significado
OnEnter Se genera en el momento en que el cuadro de texto se convierta en el control activo del
formulario.
OnExit Se genera en el momento en que el cuadro de texto deja de ser activo en el formulario.
OnChange Cada vez que se realice una modificación en el contenido del campo de texto, insertando un
nuevo carácter o borrando parte del contenido.
TMaskEdit (Additional): Con este control se puede establecer una máscara de control. Este
componente sirve para implementar un control TEdit con un formato de entrada genérico. Dicha
máscara es una cadena de caracteres en la cual algunos tienen un significado especial. Esta cadena
tendrá que asignarse a la propiedad EditMask. Durante la ejecución, la máscara que hayamos
aplicado condicionará tanto la introducción de datos en el campo como la visualización de éstos. Una
máscara consta de tres campos separados por un punto y coma. El primer campo es la máscara de
entrada. El segundo campo es el carácter que determina si los caracteres de la máscara se deben
guardar junto con los datos. El tercero es el carácter de la máscara usado para representar los
caracteres que no contiene la máscara de validación.
Caracter Significado
C Requiere la entrada de un carácter.
c Permite la entrada de un carácter.
A Requiere la entrada de un carácter alfanumérico.
a Permite la entrada de un carácter alfanumérico.
L Requiere la entrada de un carácter alfabético.
l Permite la entrada de un carácter alfabético.
0 Requiere la entrada de un carácter numérico.
9 Permite la entrada de un carácter numérico.
# Permite la entrada de un carácter numérico o de signo.
< Los caracteres siguientes aparecerán en mayúsculas.
> Los caracteres siguientes aparecerán en minúsculas.
<> Desactiva la función de los dos caracteres anteriores.
\ Interpreta el carácter siguiente como no especial.
_ Representa un espacio en blanco.
: Separador de horas y minutos.
/ Separador de fechas.
; Separador interno de la máscara.
A través de la propiedad EditMask permite activar la ventana de edición de la máscara que

actuará en el campo de texto. Otras propiedades que pueden ser tratadas en este componente son:
BorderStyle, Left, Top, Width, Height, AutoSize, Hint, ShowHint, Tag, Cursor y Font.
TMemo (Standard): Este control es muy similar al control TEdit, con la diferencia de que es posible
trabajar con una mayor extensión de texto, que además puede estar distribuido en múltiples líneas.
Las propiedades de este control coinciden en su mayor parte con las del control TEdit.
Lines Permite activar la ventana de edición para la introducción de múltiples líneas de texto.
También se puede recuperar el contenido de un archivo, así como guardar el texto actual del
control en un archivo.
WordWrap Si el valor de la propiedad es verdadero, el cursor se desplazará a la línea siguiente en el
mismo momento en que llegue al margen derecho, dividiendo automáticamente la línea por la
última palabra.
ScrollBars Facilita el desplazamiento por el texto activando las respectivas barras de desplazamiento.
Valores:
ssNone = Ninguna (valor por defecto).
ssHorizontal = Horizontal.
ssVertical = Vertical.
ssBoth = Ambas (vertical y horizontal).
WantTabs Si el valor de la propiedad es verdadero, se puede hacer uso de la tecla tabulador.
WantReturns Si el valor de la propiedad es verdadero, se puede hacer uso de la tecla Enter o Intro.
Entre los métodos más usados del componente TMemo se nombran los siguientes:
Método Significado
Add Permite añadir texto al final del contenido actual existente en el control.
Insert Permite insertar texto en el control en una cierta posición.
Delete Permite eliminar texto existente en el control.
Move Permite mover una determinada línea de una posición a otra.
Exchange Intercambia la posición de dos cadenas de texto.
LoadFromFile Captura el texto contenido en el control para un archivo de texto.
SaveToFile Permite guardar el contenido actual del control en un archivo de texto.
Una de las grandes limitaciones del control es que no permite usar atributos diferentes para el
texto, como tamaños o estilos, ni dispone de capacidad alguna de alineación, sangrado de párrafos,
etc.
TListBox (Standard): Este control es capaz de contener cadenas de caracteres cada una de las
cuales aparece como elementos de la lista. En caso de que el número de elementos excede las
dimensiones de la lista, en el control aparecen las barras de desplazamiento.
Items Permite editar los elementos que contendrá la lista.
Columns Especifica el número de columnas que existirán en el contenedor.

Sorted Si el valor de la propiedad es verdadero, muestra los elementos ordenados alfabéticamente.

IntegralHeight Si el valor de la propiedad es verdadero, la lista toma un valor proporcional a la altura de un
elemento, evitando la visualización parcial de un elemento.
ItemIndex Permite conocer que elemento está seleccionado actualmente en la lista. El valor –1 por
defecto indica que no hay ningún elemento seleccionado.
MultiSelect Si el valor de la propiedad es verdadero, permite seleccionar más de un elemento de la lista
(tecla Ctrl + pulsación del botón izquierdo).
SelCount Conocer cuantos elementos hay marcados actualmente.
Selected Conocer que elementos están marcados de la lista.
Style Permite presentar otros objetos, como elementos gráficos. Valores:
ibStandard = Todos los elementos son cadenas.
ibOwnerDrawFixed = Cada elemento es distinto pero con una altura fija.
ibOwnerDrawVariable = Cada elemento tiene una altura variable.
ItemHeight Especifica la altura en puntos de los elementos de la lista.
Canvas Permite dibujar el elemento sobre la superficie de la lista.
Por medio del método Add por el que se consigue incluir los primeros elementos de la lista
cuando se crea el formulario. También intervenir el usuario en tiempo de ejecución de manera que los
que él escriba en un control, TEdit por ejemplo, se asigne como un nuevo elemento de la lista.
TComboBox (Standard): Este control es una combinación del TListBox y TEdit, al que se conoce
como lista combinada. Al tratarse de un control combinado que tiene funciones de un campo de
edición y de una lista, las propiedades de una lista combinada son un conjunto que resulta de la unión
de las propiedades de los dos controles antes mencionados, contando con algunas propiedades
adicionales especificas.
Style Permite elegir el estilo adecuado del control. Valores:
csDropDown = Lista con campo de edición asociado.
csSimple = Campo de edición sin lista.
csDropDownList = Lista sin campo de edición.
csOwnerDrawFixed = Elementos distintos con altura fija.
csOwnerDrawVariable = Elementos distintos con altura variable.
ItemIndex Permite conocer que elemento está seleccionado actualmente en la lista. El valor –1 por
defecto indica que no hay ningún elemento seleccionado.
Text Obtener el texto del elemento seleccionado.
DropDownCount Especifica el número máximo de elementos que se visualizaran en la lista desplegable.
En una lista combinada no es posible seleccionar múltiples elementos, por ello no existen las
propiedades MultiSelect, ExtendedSelect, SelectCount y Selected.

Componentes para Iniciar Órdenes (Botones)
TButton (Standar): Este control de área rectangular que contiene un texto en su interior y que al
pulsarlo lleva a cabo una determinada acción.
Caption Toma el texto que se mostrará en el botón, a su vez puede contar con un carácter precedido
de un &. Este carácter que aparece en el botón subrayado y haciendo uso de la tecla Alt
permite activar y pulsar el botón en un solo paso.
Default y Cancel Si el valor de la propiedad es verdadero, provoca que un cierto botón actúe como botón por
defecto o de cancelación.
ModalResult Un cuadro de diálogo modal se caracteriza por no permitir el acceso a ninguna otra ventana
de la aplicación mientras él se encuentre abierto, y al cerrarlo generalmente se devuelve un
valor indicando la causa de la salida. Valores:
mrNone = 0
mrYes = idYes
mrNo = idNo
mrOk = idOk
mrCancel = idCancel
mrAbort = idAbort
mrRetry = idRetry
mrIgnore = idIgnore
Otras propiedades que pueden ser manipuladas en el TButton, tal es el caso de: Name, Font, Enabled, Tag y
Cursor.
TBitBtn (Additional): Este es un tipo de botón que incorpora un gráfico en su interior de manera
adicional al texto. Este botón es más intuitivo ya que el gráfico ofrece una indicación que en la
mayoría de los casos, hace innecesario el texto. Este componente cuenta con algunas propiedades
adicionales que permitan mostrar una pequeña imagen en el botón. Entre las propiedades de este
componente se mencionan las siguientes:
Glyph Permite asociar una imagen al botón, para ello se debe recuperar la imagen desde el archivo
donde se encuentre.
NumGlyphs Permite que el componente conozca cuantas imágenes hemos incluido en el gráfico. El
gráfico que se cree puede realmente contener hasta cuatro imágenes, dispuestas junto a la
otra horizontalmente.
Margin Determina el número de puntos de separación entre el borde del botón y el gráfico.
Layout Determina la posición del gráfico en el interior del botón. Valores:
blGlyphLeft = A la izquierda.
blGlyphTop = En la parte superior central.
blGlyphRight = A la derecha.
blGlyphBottom = En la parte inferior central.
Spacing Determina el número de puntos de separación entre el borde del botón y el texto.

Kind Selección del tipo de botón con gráfico predefinido por la propiedad en cuestión.
Otras propiedades tratadas en el aparte referido al TButton, pueden ser manipuladas en el TBitBtn, tal es el
caso de: Name, Caption, Font, ModalResult, Default, Cancel, Enabled, Tag y Cursor.
TSpeedButton (Additional): Este componente es un botón que contiene solo un gráfico en su

interior, sin texto, y para ser utilizado de forma conjunta con otros botones del mismo tipo.
GroupIndex Permite crear grupos de botones que funcionarán de forma conjunta, de tal forma que al
pulsar uno de ellos los demás se muestren liberados. Para crear un grupo tendremos que
modificar a un valor distinto a cero, este valor debe ser mismo para todos los botones que
formarán parte del grupo.
Down Si el valor de la propiedad es verdadero, el botón se encuentra pulsado.
AllowAllUp Si el valor de la propiedad es verdadero, se consigue que todos los botones del grupo
pueden estar liberados y para cambiar su estado, de liberados a pulsados o viceversa.
Flat Si el valor de la propiedad es falso, causa que los botones aparezcan resaltados en la barra,
con un recuadro alrededor. Cuando el valor es verdadero, los botones serán planos
destacándose sobre los demás solo cuando el cursor del mouse pase sobre ellos.
Otras propiedades tratadas en el aparte referido al TBitBtn, pueden ser manipuladas en el TSpeedButton, tal es
el caso de: Glyph, NumGlyphs, Margin, Layout, Hint, ShowHint y Spacing.
TToolBar (Win32): Este componente tiene como uso servir de contenedor de botones del tipo
TToolButton. Al insertar un componente de este tipo en el formulario lo único que se observará un
área rectangular ocupando la parte superior de la ventana.
ButtonHeight y Los botones existentes en la barra tendrán las mismas dimensiones (alto y ancho). Estas
ButtonWidth dimensiones deberán estar acorde con el tamaño de las imágenes que se vayan a mostrar
en el interior de los botones.
Images Contiene el nombre de las imágenes que representan a los botones en su estado normal.
DisabledImages Contiene el nombre de las imágenes que representan a los botones cuando esten
desactivados.
HotImages Contiene el nombre de las imágenes que se usarán al momento de situar el cursor sobre los
botones, haciéndoles aparecer destacados sobre los demás.
Otras propiedades tratadas en otros componentes pueden ser manipuladas en el TToolBar, tal es el caso de:
Align, AutoSize, Color, Hint, ShowHint y Transparent.
Puesto que en la barra (TToolBar) existen múltiples botones, será necesario disponer de
múltiples imágenes en cada estado (normal, desactivado o caliente) en distintos TImageList.
Desplegando el menú contextual del componente, aparecen dos opciones: New Button y New
Separator, que son las que facilitan en la barra de un nuevo botón o un separador, respectivamente.
Cada uno de los botones insertados en la barra es un componente TToolButton que cuenta con sus
propiedades y eventos.

Caption Permite establecer el título asociado al botón.
ImageIndex Indica el índice de la imagen que se ha de mostrar en el interior del botón.
Style Indica el tipo de estilo que va a contener el botón. Valores:
tbsButton = Un botón normal.
tbsCheck = Botón que puede estar o no pulsado.
tbsDivider = Línea Divisoria.
tbsDropDown = Botón con un menú desplegable.
tbsSeparator = Espacio de separación.
PopupMenu Nombre del menú que estará asociado con el estilo tbsDropDown. El menú deberá estar
diseñado a través del componente TPopupMenu y será un menú que se activará por medio
del botón derecho del mouse.
Otras propiedades pueden ser tratadas en este componente, tal es el caso de: Down, Hint, ShowHint y Cursor.
TImageList (Win32): Este componente es un contenedor de imágenes del mismo tamaño (grupos de
iconos o mapa de bits), cada una de las cuales puede ser referenciada por su índice, cuyos nombres
se asignarán a las propiedades Images, DisabledImages, HotImages. En la mayoría de las ocasiones
este componente será usado en conjunción con un TToolBar, TTreeView o TListView.
AllocBy Incremento cada vez que sea necesario aumentar el número de imágenes.
BkColor Color de fondo a utilizar al dibujar una imagen.
BlendColor Color de combinación.
Count Número de imágenes contenidas.
DrawingStyle Estilo para el dibujo de una imagen.
Height Altura de las imágenes.
ImageType Tipo de imagen a utilizar para dibujar.
Masked Indica si la imágenes son transparentes o no.
ShareImages Indica si las imágenes son compartidas con otro control.
Width Anchura de las imágenes.
Todas las imágenes contenidas en este componente deben tener exactamente el mismo tamaño, así para
imágenes de diferentes dimensiones se tendrá que usar varios componentes TImageList.
Tras insertar el componente haga doble clic sobre él, luego aparecerá una ventana en donde se
podrá ir añadiendo imágenes mediante el botón “Add”, estableciendo adicionalmente parámetros
como el color que sea transparente, si la imagen se ajusta a las dimensiones por defecto, se corta o
aparece centrada.

Componentes de Selección de Opciones o Valores
TCheckBox (Standard): Este control permite al usuario activar o desactivar una cierta opción sin
necesidad de escribir nada, bastará con realizar una pulsación sobre el control. Mediante este control
se facilita la selección de múltiples opciones. Entre las propiedades de este componente se
mencionan las siguientes:
Caption Permite asignar el título que aparecerá junto a la caja de selección.
Checked Determina el estado actual del control. Habitualmente este control puede aparecer en dos
estados distintos: marcado (true) o sin marcar (false).
AllowGrayed Si el valor de la propiedad es verdadero, el control no aparecerá ni marcado ni sin marcar, un
estado indeterminado.
State También determina el estado actual del control. Valores:
cbChecked = Marcado.
cbUnchecked = Desmarcado.
cbGrayed = Indeterminado.
TRadioButton (Standard): Este control permite al usuario activar o desactivar una cierta opción,
bastará con elegir cualquier opción desmarcando el botón de radio que se encontraba marcado en
dicho momento. Mediante este control se facilita la selección de una sola opción en un determinado
instante. Las propiedades más usadas son el Caption y el Checked.
TGroupBox (Standard): La finalidad de este componente es actuar como padre o contenedor de

otros componentes, agrupándolos y no dispone de ninguna propiedad en especial. Al insertar el
componente en el formulario, éste aparecerá como un recuadro, con un título en la parte superior
izquierda (Título que podrá ser modificado a través de la propiedad Caption). Aunque los controles
que normalmente se agrupan son los botones de radio, mediante este componente se pueden
agrupar cualquier conjunto de controles, sin importar su tipo.
En el caso de disponer de un determinado componente en el formulario y lo desplacemos al

interior del TGroupBox, lo único que realmente hecho será modificar su posición, pero realmente
dicho componente no estará contenido en el grupo.
Las propiedades ParentFont, ParentColor y ParentShowHint toman el valor de verdadero,

indicando así que los valores de las propiedades Font, Color y ShowHint de un determinado
componente insertado serán tomados del contenedor TGroupBox.
TRadioGroup (Standard): C++ Builder dispone de este control para facilitar el tratamiento de grupos
de botones de radio, ya que dispone de unas propiedades adicionales a las del control anterior que
permiten disponer los botones de radio de una forma más cómoda, así como conocer cuál de ellos
está seleccionado consultando una sola propiedad.
Items Permite editar los botones de radio que existirán dentro del control.

Columns Especifica el número de columnas que existirán en el contenedor.

ItemIndex Permite conocer que botón está seleccionado actualmente como para modificar dicha
selección. El valor –1 por defecto indica que no hay seleccionado ninguno de los botones.
Esta propiedad evita la construcción de múltiples decisiones con el fin de conocer la
selección actual dentro del contenedor.
TCheckListBox (Additional): La particularidad de este componente consiste en que cada elemento

aparece con una caja de selección a su izquierda, de tal forma que es posible marcar o desmarcar
como si se tratasen de controles TCheckBox individuales. Entre las propiedades de este componente
se mencionan las siguientes:
Items Permite editar las cajas de selección que existirán dentro del control.
Checked Determina el estado actual del control marcado o desmarcado.
ItemEnabled Permite activar y desactivar los elementos de lista que convenga.
TPanel (Standard): Este componente tiene como uso servir de contenedor de otros componentes o
como barra de estado.
BevelInner y Se fija el estilo del panel que puede aparecer resaltado o hundido en el formulario. Valores:
BevelOuter bvNone = Sin ningún efecto.
bvLowered = Hundido.
bvRaised = Resaltado.
BorderWidth Establece la anchura del borde del panel.
Otras propiedades tratadas en otros componentes pueden ser manipuladas en el TPanel, tal es el caso de:
Caption, Font y Align.

Ejercicios Resueltos
/* Proyecto 1: Este proyecto tiene como finalidad será mostrar los atributos asignados por el usuario a
una etiqueta de texto durante la ejecución, y a través de botones, se podrá controlar el tipo, estilo,
tamaño y color */
//------------------------------------------------------------------------------
void __fastcall TForm1::BotonArialClick(TObject *Sender)
{
Etiqueta->Font->Name="Arial";
}
//-------------------------------------------------------------------------------
void __fastcall TForm1::BotonCourierClick(TObject *Sender)
{
Etiqueta->Font->Name="Courier";
}
//-------------------------------------------------------------------------------
void __fastcall TForm1::BotonNegritaClick(TObject *Sender)
{
CambiaEstilo(fsBold);
}
//-------------------------------------------------------------------------------
void __fastcall TForm1::BotonCursivaClick(TObject *Sender)
{
CambiaEstilo(fsItalic);
}
//-------------------------------------------------------------------------------
void TForm1::CambiaEstilo(TFontStyle Estilo)
{
if (Etiqueta->Font->Style.Contains(Estilo))
Etiqueta->Font->Style=Etiqueta->Font->Style>>Estilo; //Eliminamos el estilo
else
Etiqueta->Font->Style=Etiqueta->Font->Style<<Estilo; //Añadimos el estilo
}
//------------------------------------------------------------------------------
void __fastcall TForm1::MasClick(TObject *Sender)
{
Etiqueta->Font->Size+=2;
}
//------------------------------------------------------------------------------
void __fastcall TForm1::MenosClick(TObject *Sender)
{
Etiqueta->Font->Size-=2;
}
/* Proyecto 2: La finalidad de este proyecto es el de calcular el sueldo neto y deducciones de un

empleado. Nota: Incluir la cabecera de archivo <fstream.h> */
//------------------------------------------------------------------------------
void __fastcall TForm1::CalcularClick(TObject *Sender)
{
AnsiString n,p,h,salida;
float sn,sb,sso,lph;
n=Nombre->Text;
p=Pago->Text;
h=Horas->Text;
sn=atof(p.c_str( ))*atof(h.c_str( ));
sso=sn*0.05;
lph=sn*0.01;
sb=sn-(sso+lph);
salida="Calculos de Nomina\n"
"*****************\n\n"
"Nombre: "+n+
"\nSueldo Neto: "+AnsiString(sn)+
"\nSeguro Social: "+AnsiString(sso)+
"\nPolitica Habitacional: "+AnsiString(lph)+
"\nSueldo Básico: "+AnsiString(sb);
ShowMessage(salida);
ofstream F("NOMINA.TXT");
F<<salida.c_str( );
F.close( );
}
/* Proyecto 3: Presentación de un formulario que le da entrada a los datos de un aspirante, verifica

ciertas condiciones y al que las cumpla se visualizara una etiqueta indicando el siguiente mensaje: “El
estudiante procesado cumple con los requisitos mínimos para jugar Basketball”. Guardar todos los
estudiantes procesados en un archivo */

//------------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{
Guardar->Visible=false;
}
//------------------------------------------------------------------------------
void __fastcall TForm1::EdadKeyPress(TObject *Sender, char &Key)
{
//Si no es un dígito numérico no admitir la pulsación de tecla
if ((Key< '0'||Key> '9') && Key!=8) Key=0;
}
//------------------------------------------------------------------------------
void __fastcall TForm1::EstaturaKeyPress(TObject *Sender, char &Key)
{
if ((Key< '0' ||Key> '9') && Key!=8) Key=0;
}
//------------------------------------------------------------------------------
void __fastcall TForm1::PesoKeyPress(TObject *Sender, char &Key)
{
if ((Key< '0'||Key> '9') && Key!=8) Key=0;
}
//------------------------------------------------------------------------------
void __fastcall TForm1::VerificarClick(TObject *Sender)
{
AnsiString ed,es,pe;
ed=Edad->Text;
es=Estatura->Text;
pe=Peso->Text;
if (atoi(ed.c_str( ))<18 && atoi(es.c_str( ))>180 && atof(pe.c_str( ))<80)
{
Verificar->Enabled=false;
Etiqueta8->Caption="El estudiante procesado cumple con los requisitos mínimos para jugar
Basketball";
Guardar->Visible=true;
}
}
//------------------------------------------------------------------------------
void __fastcall TForm1::GuardarClick(TObject *Sender)
{
AnsiString salida;
salida=Nombre->Text+"\t"+Edad->Text+" años\t"+Estatura->Text+" cm.\t"+Peso->Text+" Kg.\n";

ofstream A("ADMITIDOS.TXT",ios::app);
A<<salida.c_str( );
A.close( );
Guardar->Visible=false;
Verificar->Enabled=true;
Etiqueta8->Caption="";
Nombre->Text="";
Edad->Text="";
Estatura->Text="";
Peso->Text="";
}
/* Proyecto 4: La finalidad de este proyecto es la utilización de un control TMemo diseñando un pequeño

editor. Este control permitirá recuperar un archivo, introducir texto o modificar el ya existente, realizar
operaciones con el portapapeles y guardar el contenido del control en un archivo */
//------------------------------------------------------------------------------
{
Texto->Clear( );
NombreArchivo->Text="texto1.txt";
}
//------------------------------------------------------------------------------
void __fastcall TForm1::AbrirClick(TObject *Sender)
{
try
{
Texto->Lines->LoadFromFile(NombreArchivo->Text);
}
catch(...)
{
ShowMessage("El arhivo indicado no existe");
}
Texto->SetFocus( );
}
//------------------------------------------------------------------------------
void __fastcall TForm1::GuardarClick(TObject *Sender)
{
try
{
Texto->Lines->SaveToFile(NombreArchivo->Text);
}
catch(...)
{
ShowMessage("No es posible efectuar la grabación");
}
Texto->SetFocus( );
}
//------------------------------------------------------------------------------
void __fastcall TForm1::NuevoClick(TObject *Sender)
{
Texto->Clear( );
Texto->SetFocus( );
}
//------------------------------------------------------------------------------
void __fastcall TForm1::SalirClick(TObject *Sender)
{
Close( );
}
//------------------------------------------------------------------------------
void __fastcall TForm1::CopiarClick(TObject *Sender)
{
Texto->CopyToClipboard( );
Texto->SetFocus( );
}
//------------------------------------------------------------------------------
void __fastcall TForm1::PegarClick(TObject *Sender)
{
Texto->PasteFromClipboard( );
Texto->SetFocus( );
}
//------------------------------------------------------------------------------
void __fastcall TForm1::CortarClick(TObject *Sender)
{
Texto->CutToClipboard( );
Texto->SetFocus( );
}
/* Proyecto 5: La idea de este proyecto es mostrar una fotografía diferente en un control como el
TImage, y se hace el comentario respectivo de la foto en una etiqueta de texto */

//------------------------------------------------------------------------------
{
AnsiString Archivo="IP.bmp";
Imagen->Visible=false;
if (FileExists(Archivo))
{
Imagen->Visible=true;
Imagen->Picture->LoadFromFile(Archivo);
}
else
{
Etiqueta->Caption="Imagen Principal no Existe";
}
}
//------------------------------------------------------------------------------
void __fastcall TForm1::Foto1Click(TObject *Sender)
{
AnsiString Archivo="I1.bmp";
{
Etiqueta->Caption="Un verano muy cercano";
}
else
{
Etiqueta->Caption="La Fotografía no Existe";
}
}
//------------------------------------------------------------------------------
{
{
Etiqueta->Caption="Un viajero muy solitario";
}
else
{
}
}
//------------------------------------------------------------------------------
{
{
Etiqueta->Caption="Un cardenal y sus consejeros";
}
else
{
}
}
//------------------------------------------------------------------------------
void __fastcall TForm1::CerrarClick(TObject *Sender)
{
Close( );
}
/* Proyecto 6: Proyecto para seleccionar un determinado tipo de estilo y fuente para el texto introducido
por el usuario */
//------------------------------------------------------------------------------
void __fastcall TForm1::BAplicarClick(TObject *Sender)
{
TFontStyles Estilo; // Conjunto de TFontStyle
// Si está activa la caja de selección
if (CNegrita->Checked) Estilo << fsBold; // añadir el estilo fsBold
if (CItalica->Checked) Estilo << fsItalic;
if (CSubrayada->Checked) Estilo << fsUnderline;
// Pasar el estilo a la etiqueta de texto
Etiqueta->Font->Style = Estilo;
// Asignar el tipo de Fuente a la propiedad Name
if (CArial->Checked) Etiqueta->Font->Name = "Arial";
else if (CCourier->Checked) Etiqueta->Font->Name = "Courier";
else Etiqueta->Font->Name = "Roman";
}
//------------------------------------------------------------------------------
void __fastcall TForm1::CTextoChange(TObject *Sender)
{
// Cada vez que se modifique el texto en el control pasar a la etiqueta
Etiqueta->Caption = CTexto->Text;
}
/* Proyecto 7: En este proyecto se usa el control TCheckListBox y un botón para validar los días que se
agregarán al TListBox situado a la derecha del formulario. Se debe editar la propiedad Items del
TcheckListBox, asignando como elementos los siete días de la semana */

//------------------------------------------------------------------------------
{
CheckListBox1->ItemEnabled[5]=false;
CheckListBox1->ItemEnabled[6]=false;
}
//------------------------------------------------------------------------------
void __fastcall TForm1::AdiccionarClick(TObject *Sender)
{
Lista->Items->Clear( ); //Limpiar la Lista del Lado Derecho
//Recorrer los elemntos seleccionados del lado izquierdo
for (int k=0; k<CheckListBox1->Items->Count; k++)
{
if (CheckListBox1->Checked[k])
Lista->Items->Add(CheckListBox1->Items->Strings[k]);
}
}
/* Proyecto 8: Este proyecto consta de dos formularios que se interrelacionan entre sí. En el primer
formulario se le solicita al usuario una serie de datos, luego en el segundo formulario se visualizan los
mismos datos solo para la lectura sobre cuadros de texto */
//------------------------------------------------------------------------------
void __fastcall TForm1::MostrarClick(TObject *Sender)
{
Hide( ); //Cerrar el primer formulario
Form2->Show( );
Form2->RecApe->Text=Apellido->Text;
Form2->RecNom->Text=Nombre->Text;
Form2->RecFec->Text=Dia->Text+"/"+Mes->Text+"/"+Axo->Text;
Form2->RecSex->Text=Sexo->Text;
Form2->RecCiv->Text=Civil->Text;
Form2->RecTel->Text=Telefono->Text;
}
//------------------------------------------------------------------------------
void __fastcall TForm2::RegresarClick(TObject *Sender)
{
Close( ); // Cerrar el segundo formulario
Form1->Show( );
}
/* Proyecto 9: La finalidad de este proyecto es la introducción de los conceptos de botón por defecto y
botón de cancelación */
//------------------------------------------------------------------------------
void __fastcall TForm1::AceptarClick(TObject *Sender)
{
CInformacion->Text = "Aceptar";
}
//------------------------------------------------------------------------------
void __fastcall TForm1:: CancelarClick(TObject *Sender)
{
CInformacion->Text = "Cancelar";
}
//------------------------------------------------------------------------------
void __fastcall TForm1:: SalirClick(TObject *Sender)
{
CInformacion->Text = "Salir";
}

/* Proyecto 10: El propósito de este proyecto es la utilización del control TGroupBox, para seleccionar
el tamaño y la fuente a través de botones de radio */
// Cada vez que se modifique el texto en el control TEdit actualizar la etiqueta de texto
void __fastcall TForm1::CTextoChange(TObject *Sender)
{
CResultado->Caption = CTexto->Text;
}
//------------------------------------------------------------------------------
void __fastcall TForm1::AplicarClick(TObject *Sender)
{
TFontStyles Estilos; // Conjunto de TFontStyle
// Si está activa la caja de selección CNegrita
if (CNegrita->Checked)
Estilos << fsBold; // Añadir el estilo fsBold
if (CItalica->Checked)
Estilos << fsItalic;
if (CSubrayada->Checked)
Estilos << fsUnderline;
if (CTachada->Checked)
Estilos << fsStrikeOut;
// Pasar los estilos a la etiqueta de texto
CResultado->Font->Style = Estilos;
// Dependiendo del tipo seleccionado asignar el tipo de fuente a Font->Name una cadena u otra
if (CArial->Checked)
CResultado->Font->Name = "Arial";
else if (CCourier->Checked)
CResultado->Font->Name = "Courier";
else
CResultado->Font->Name = "Roman";
// Dependiendo del tamaño seleccionado asignar el tamaño de la fuente a Font->Size el valor adecuado
if (C12->Checked)
CResultado->Font->Size = 12;
else if (C14->Checked)
else
}

Builder ParteI 2016

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Builder ParteI 2016

Cargado por

Copyright:

Formatos disponibles

Lcdo. José F. Guerrero P.

República Bolivariana de Venezuela

Tema Perteneciente a la Unidad Nº 2: Programación en C++ Builder.

Autor: Lcdo. José Froilán Guerrero Pulido

Uso del Formulario (TForm)

A medida que un proyecto se inserten formularios sobre estos se añaden componentes o

Además de usar formularios individuales también se puede reutilizar aplicaciones o proyectos

A continuación se definen las propiedades más importantes del componente TForm.

111 Ing. Electrónica

112 Ing. Electrónica

Componentes Receptores de Texto de Uso más Frecuente

113 Ing. Electrónica

Text Toma el valor que se mostrará en el cuadro de texto inicialmente.

115 Ing. Electrónica

A través de la propiedad EditMask permite activar la ventana de edición de la máscara que

117 Ing. Electrónica

Sorted Si el valor de la propiedad es verdadero, muestra los elementos ordenados alfabéticamente.

118 Ing. Electrónica

Componentes para Iniciar Órdenes (Botones)

119 Ing. Electrónica

TSpeedButton (Additional): Este componente es un botón que contiene solo un gráfico en su

120 Ing. Electrónica

121 Ing. Electrónica

Componentes de Selección de Opciones o Valores

TGroupBox (Standard): La finalidad de este componente es actuar como padre o contenedor de

En el caso de disponer de un determinado componente en el formulario y lo desplacemos al

Las propiedades ParentFont, ParentColor y ParentShowHint toman el valor de verdadero,

122 Ing. Electrónica

Columns Especifica el número de columnas que existirán en el contenedor.

TCheckListBox (Additional): La particularidad de este componente consiste en que cada elemento

123 Ing. Electrónica

/* Proyecto 2: La finalidad de este proyecto es el de calcular el sueldo neto y deducciones de un

/* Proyecto 3: Presentación de un formulario que le da entrada a los datos de un aspirante, verifica

125 Ing. Electrónica

salida=Nombre->Text+"\t"+Edad->Text+" años\t"+Estatura->Text+" cm.\t"+Peso->Text+" Kg.\n";

/* Proyecto 4: La finalidad de este proyecto es la utilización de un control TMemo diseñando un pequeño

128 Ing. Electrónica

130 Ing. Electrónica

132 Ing. Electrónica

133 Ing. Electrónica

También podría gustarte