Está en la página 1de 53

Uso básico de C++ Builder

© Jesús Salas Parrilla

Unidad

2b

Uso básico de C++ Builder

Fichas o ventanas (Forms)
Las fichas tienen varias propiedades, métodos y eventos, los cuales se pueden usar visualmente o haciendo referencia a ellos mediante el código. Las propiedades modificables en tiempo de diseño más importantes son las siguientes:

Propiedad

Significado
Nombre de la ficha. Esta propiedad contiene el identificador de la ficha que es utilizado dentro del programa como una variable. Es conveniente que todas las fichas de nuestro programa posean identificadores propios y que den pistas sobre el contenido de la ficha. Su contenido es un identificador. Título de la ficha. Todas las fichas poseen en la parte superior un título, el cual se modifica mediante la propiedad Caption. El contenido de Caption coincide, inicialmente, con el contenido de Name, pero no tienen que coincidir a la fuerza. El contenido es de tipo AnsiString. La propiedad Position toma un valor por defecto que es poDesigned. Este valor hace que la ficha aparezca en pantalla con la misma posición que tenía cuando se diseñó. Este valor no es el más adecuado cuando el diseño de la aplicación se realiza con monitores de gran tamaño.

Name

Caption

Position.poDesigned

Entornos de desarrollo

1

Uso básico de C++ Builder

© Jesús Salas Parrilla

Position.poDefault

Este valor produce que los valores de las 4 propiedades anteriores varíen de forma aleatoria en cada ejecución del programa. Esta opción tampoco es muy apropiada ya que puede ocurrir que una ficha no aparezca en pantalla estando abierta. Con este valor en la propiedad Position se hace que el tamaño de la ficha permanezca fijo, mientras que la posición va cambiando con cada ejecución. Inversa a la anterior, conserva la posición de la ficha pero el tamaño es fijado en tiempo de ejecución. Con este valor se consigue que la ficha aparezca en el centro de la pantalla con el tamaño original de diseño. Es una propiedad que puede contener tres valores posibles: wsNormal, wsMinimize y wsMaximize. Con el primer valor, la ficha aparece según el diseño y según el valor de la propiedad Position. Con el segundo valor, la ficha aparece minimizada en forma de un icono. Con el tercer valor, la ficha aparece ocupando toda la pantalla o maximizada. Esta propiedad permite escalar la ficha y su contenido. Si contiene el valor TRUE, permite el escalado. Si posee el valor de FALSE, no permite el escalado. Es un conjunto de valores que cada uno de ellos tiene el siguiente significado: TRUE: visualiza un botón en la esquina superior derecha que permite minimizar la ventana. FALSE: no aparece dicho botón. TRUE: visualiza un botón en la esquina superior derecha que permite maximizar la ventana abierta. TRUE: visualiza un botón en la esquina superior derecha que sirve para cerrar la ventana. También visualiza un botón en la esquina superior izquierda con un menú de sistema. Esta propiedad puede tener 6 valores diferentes: Este valor lo coge la ficha por defecto. Permite hacer la ficha lo grande que el usuario desee. Hace que el borde de la ficha aparezca algo más fino que en el estado normal.

poDefaultPosOnly poDefaultSizeOnly poScreenCenter

WindowState

Scaled

BorderIcons - biMinimize - biMaximize

- biSystemMenu BorderStyle - bsSizeable - bsSingle

Entornos de desarrollo

2

Uso básico de C++ Builder

© Jesús Salas Parrilla

- bsToolWindow - bsDialog - bsNone - bsSizeToolWin

Como el anterior, pero con una barra de título menor, al estilo de las barras de herramientas. Con este valor, la ficha aparece según se ha diseñado, sin los botones minimizar y maximizar. Elimina el borde de la ventana, así como la barra de título con todos sus controles. Esta opción hace los bordes redimensionables con una barra de título menor de lo normal. Por defecto esta propiedad tiene el valor TRUE. Dándole el valor de FALSE a esta propiedad desactivaremos el efecto tridimensional, quedando el fondo de la ficha en blanco. Esta propiedad permite cambiar el color de la parte cliente de la ficha. Esta propiedad almacena el identificador de la propiedad Name del menú principal insertado en la ficha. Esta propiedad almacena el identificador de la propiedad Name del menú flotante asignado a la ficha. Propiedad que contiene la cadena de caracteres que aparece en la ayuda flotante junto al ratón. Si esta propiedad está con el valor TRUE se visualiza la ayuda flotante y si está a FALSE no se visualiza dicha ayuda. TRUE: la ficha está activa. FALSE: la ficha no está activa. TRUE: la ficha se hace visible si Enabled está a true. FALSE: la ficha no es visible. fsNormal: no puede contener otras ventanas en su interior ni ser a su vez contenida en otra ventana. fsMDIForm: puede contener en su interior otras ventanas. fsMDIChild: son las ventanas que van a estar dentro de otra. fsStayOnTop: es para una ventana que siempre estará en el primer plano o visible en su totalidad. Es la propiedad que permite dar formato a todos los caracteres que existan dentro de la ficha. Cuando está con el valor de TRUE permite que aparezcan barras de desplazamiento dentro de la ventana cuando las dimensiones de ésta se reducen con el ratón.

Ctl3D

Color Menu PopupMenu Hint ShowHint Enabled Visible

FormStyle

Font AutoScroll

Entornos de desarrollo

3

Uso básico de C++ Builder

© Jesús Salas Parrilla

ActiveControl HelpContext ObjectMenuItem

Permite seleccionar el componente de los que contiene la ficha para que aparezca activado al abrir la ficha. Mediante esta propiedad podemos asociar a la ficha una determinada página de ayuda contextual. Se utiliza para indicar las opciones de un menú que se activarían cuando se seleccione un objeto mediante el OLE. poNone: no mantiene proporción alguna. poProportional: imprime el mismo número de puntos en impresora que en pantalla. poPrintToFit: ocupa el mayor espacio posible de la página manteniendo la proporción de la ficha. No tiene significado alguno. Esta propiedad es de tipo Longint y se utiliza como variable para poder almacenar valores enteros. FALSE: las pulsaciones de teclas que se produzcan durante la ejecución del programa pasan directamente al control de la ficha. TRUE: las pulsaciones de teclas son enviadas a la ficha y después al control de la ficha. Esta propiedad de sólo lectura podrá ser consultada por el código de la ficha principal o desde donde se llama a la actual ficha. Los valores que puede tomar esta propiedad están desglosados en el componente Button.

PrintScale

Tag

KeyPreview

ModalResult

Los eventos son procedimientos que se ejecutan cuando se produce algún suceso que se pretende controlar mediante programa. Algunos eventos de la ficha se repiten en otros componentes que puede contener la ficha. Los eventos de una ficha son:

Eventos

Significado
Cuando el puntero del ratón se mueve por la ficha se ejecuta este evento. El evento recibe 3 parámetros: X e Y que son de tipo entero e indican la posición del cursor expresada en puntos, y Shift que es de tipo conjunto que contendrá uno de los siguientes valores dependiendo de qué teclas y botones del ratón estén pulsados.

OnMouseMove

Entornos de desarrollo

4

Uso básico de C++ Builder

© Jesús Salas Parrilla

ssShift ssAlt ssCtrl ssRight ssLeft ssMiddle ssDouble

Una de las teclas de mayúsculas. La tecla <Alt> La tecla <Control> El botón derecho del ratón El botón izquierdo del ratón El botón central del ratón Los botones izquierdo y derecho del ratón.

OnMouseDown

Se ejecuta cuando se pulsa cualquiera de los botones del ratón estando éste sobre la ficha. Si el botón pulsado es el izquierdo y el puntero está encima de un componente toma el control este componente y no se ejecuta el evento. El evento recibe 3 parámetros: X, Y, Shift y Button. Este último puede tomar tres valores: mbRight (botón derecho), mbLeft (botón izquierdo) y mbMiddle (botón central). Cada vez que se libera un botón del ratón sobre un control, éste recibe el evento OnMouseUp. Los parámetros son idénticos al evento anterior. Este evento también puede ejecutarse por la pulsación de la barra espaciadora sobre un control o la pulsación de la tecla <Intro> o <Escape>. En la mayoría de las ocasiones se ejecuta por la pulsación del botón izquierdo del ratón. Se ejecutará cuando se pulse dos veces seguidas con el botón izquierdo del ratón. Se ejecuta al pulsarse una tecla. Se ejecuta al liberar una tecla. Se ejecuta cuando se pulsa una tecla alfanumérica. Cuando se arrastra un objeto, aplicando la filosofía de arrastrar y soltar, al pasar el objeto por encima de un control se ejecuta varias veces el evento OnDragOver correspondiente al control. Se ejecuta una sola vez al soltar el objeto encima del control. Se ejecuta cuando la ficha va a ser creada permitiendo realizar inicializaciones. Este evento se ejecuta en el momento en que la ficha se convierte en la ventana activa en el entorno.

OnMouseUp

OnClick

OnDblClick OnKeyDown OnKeyUp OnKeyPress OnDragOver OnDragDrop OnCreate OnActivate

Entornos de desarrollo

5

caNone. cuando la ficha se minimiza. como objetos que son. que recibe como parámetro por referencia el llamado Action que puede contener los valores: caFree. Este evento recibe el parámetro por referencia CanClose al que daremos el valor TRUE o FALSE dependiendo de que se permita o no dicho cierre. Antes de realizar el cierre de la ventana se ejecuta este evento. cuando la ficha se oculta. caMinimize. porque se haya cambiado a otra ventana o aplicación. que se puede aprovechar para modificar la disposición de los controles en su interior según el nuevo tamaño. Cuando la ficha se va a destruir y a liberar la memoria ocupada. OnClose OnCloseQuery OnDestroy OnEnter. Cada vez que el tamaño de una ficha sea modificado durante la ejecución se generará este evento. Trae la ficha del fondo al primer plano.Uso básico de C++ Builder © Jesús Salas Parrilla OnShow OnHide OnDeactivate Se ejecuta justo antes de que la ficha se haga visible. Cierra la ficha Entornos de desarrollo 6 . Se ejecuta cuando se va a cerrar la ficha. caHide. entre los más usuales están: Métodos Show BringToFront SendToBack Hide Close Significado Visualiza la ficha encima de las ventanas que estén abiertas. Envía la ficha del primer plano al fondo de la pantalla. cuando no se permite el cierre de la ficha. Este evento se ejecuta cada vez que la ficha necesita ser dibujada. Hace que se oculte la ficha pero no se cierra. Se ejecuta justo antes de que la ficha sea ocultada. se ejecuta este evento. pudiendo acceder a los componentes de la ficha. OnExit OnPaint OnResize Las fichas. cuando la ficha es cerrada. Este evento se ejecuta cuando la ficha se vuelve inactiva. El evento OnEnter entra en ejecución en el componente que se activa y OnExit en el componente que se desactiva. también tienen métodos.

Es la posición en puntos que tiene el objeto con respecto al primer borde superior de la ficha. para continuar con la aplicación se debe cerrar la ficha abierta con ShowModal. Label (etiquetas) Las propiedades más usuales son: Propiedades Name Caption Left Top Visible Width Height Significado Contiene un identificador mediante el cual se identifica el objeto. Hace que la ficha se visualice y la aplicación no pueda continuar mientras esté abierta.Uso básico de C++ Builder © Jesús Salas Parrilla Destroy Print ShowModal Destruye la ventana. Expresa cuántos puntos mide de alto el objeto. Se pone a FALSE cuando se quiere que el objeto tenga siempre la misma forma. Puede tomar distintos valores dependiendo de las necesidades: AutoSize Align Entornos de desarrollo 7 . Se utiliza para imprimir la ficha. Si contiene el valor TRUE se hace visible. Una vez que la ficha ha sido destruida no será posible acceder a sus componentes. Expresa el ancho del objeto. Hay que ponerle a TRUE cuando se quiere que el tamaño del objeto se adapte al texto mostrado en tiempo de ejecución. Si contiene el valor FALSE dicha etiqueta no será visible. Es una cadena de caracteres la cual es visualizada en el interior del objeto. Es la coordenada que tiene el objeto respecto al borde izquierdo de su contenedor.

Esta propiedad hace referencia al color de fondo del objeto. Se adapta al margen inferior del contenedor. La gran ventaja de la POO permite que las características de ésta propiedad sean diferentes de las heredadas de la ficha. FALSE: el símbolo & pierde su significado y aparece en la etiqueta como un carácter más. Esta propiedad permite que el fondo de un objeto sea transparente. Se adapta al margen derecho del contenedor. si AutoSize es FALSE el texto se adapta a las dimensiones que el programador le asigne a la caja de texto. Justificado al centro. esta propiedad puede tomar 3 valores diferentes: Alignmemt taLeftJustify taRightJustify taCenter Justificado a la izquierda. Si a la propiedad Font de la ficha se le ha asignado algunas características diferentes de las que contiene por defecto. Esta es una propiedad mediante la cual se puede apreciar fácilmente la herencia. Toma todo el espacio disponible del contenedor. Justificado a la derecha. WordWrap Cuando está a FALSE. Font Color Transparent ShowAccelChar Entornos de desarrollo 8 . Se coloca en el margen superior del contenedor. la etiqueta contiene varias líneas de texto con los márgenes de la caja de texto ajustados a la dimensión de la palabra más larga. el texto que contiene la propiedad Caption solamente se visualiza en una única línea independientemente del valor que contenga la propiedad AutoSize. es decir.Uso básico de C++ Builder © Jesús Salas Parrilla alNone alTop alBottom alLeft alRight alClient Conserva la posición y dimensiones originales. Si AutoSize contiene el valor FALSE. Si posee el valor TRUE y la propiedad AutoSize también contiene TRUE. Se coloca en el margen izquierdo del contenedor. que se pueda observar otro objeto que esté debajo. TRUE: permite en Caption la escritura de letras subrayadas anteponiéndole el símbolo & a dicha letra. las etiquetas que se añadan a la ficha tendrán por defecto las características de las fuentes de la ficha.

es decir. Flecha con documento para arrastrar y soltar. FALSE: la etiqueta se visualiza desactivada. TRUE: permite visualizar la etiqueta de ayuda que aparece escrita en la propiedad Hint. Señal de prohibido. TRUE: en este caso la etiqueta se visualiza con todas sus propiedades. Doble flecha horizontal. Reloj de arena. Puntero habitual en forma de flecha inclinada. Pulsando ALT y la letra de la etiqueta que esté subrayada se activa el objeto que esté asociado a la etiqueta. ShowHint Hint ParentShowHint Enabled Visible Cursor Entornos de desarrollo 9 . FALSE: no visualiza la etiqueta del objeto contenedor. Flecha doble indicando cambio de tamaño. Flecha doble indicando cambio de tamaño. está activa. TRUE: la etiqueta se visualiza. El cursor de texto. Flecha vertical con la punta hacia arriba. Los valores posibles de esta propiedad son: CrDefault CrArrow CrCross CrlBeam CrSize CrSizeNESW CrSizeNS CrSizeNWSE CrSizeWE CrUpArrow CrHourglass CrDrag CrNoDrop CrHSplit crVSplit La que tenga actualmente. FALSE: no visualiza la etiqueta de ayuda. Flecha doble indicando cambio de tamaño. Doble flecha vertical.Uso básico de C++ Builder © Jesús Salas Parrilla FocusControl Nos permite seleccionar el objeto al cual va a estar ligada la etiqueta. TRUE: si ShowHint está a falso implica que se visualizará la etiqueta de ayuda del objeto contenedor. Propiedad que contiene la etiqueta de ayuda que se visualizará cuando se pase con el ratón por encima del objeto. Permite seleccionar la forma que tendrá el cursor del ratón cuando pase por encima de la etiqueta. Cuatro flechas unidas indicando reposicionamiento Flecha doble indicando cambio de tamaño. FALSE: la etiqueta no se visualiza. Una cruz.

FALSE: el componente está inactivo y. Su contenido puede ser editado en tiempo de ejecución. aunque sea visible. Visible Si contiene el valor TRUE se hace visible. Cuando está activo este componente se puede introducir a través de él una cadena de caracteres. Esta propiedad hereda el tipo de letra del componente que contenedor. Enabled AutoSize Hint. Permite dar color al fondo del componente. el componente no puede ser editado hasta que no se ponga esta propiedad a verdad. Propiedades que permiten asignar al componente una etiqueta de ayuda contextual. Permite asignarle al componente un tipo de letra particular. la cual se almacena en esta propiedad.Uso básico de C++ Builder © Jesús Salas Parrilla El componente Edit (edición de datos) Las propiedades más usuales son: Propiedades Name Significado Contiene un identificador mediante el cual se identifica el objeto. FALSE: El componente tiene siempre la dimensión que le asigne el programador. TRUE: el componente se ajusta a la dimensión de letra que contiene. Width y Son propiedades cuyo significado coincide con los vistos en la Height ficha. Text Left. ShowHint Color Font Entornos de desarrollo 10 . Es una propiedad de tipo cadena (string). Si contiene el valor FALSE dicho objeto no será visible. A esta propiedad se le puede asignar cualquier valor inicial que el programador desee. TRUE: El componente está activo y puede ser editado en tiempo de ejecución. Top.

Contiene el número máximo de caracteres que puede almacenar. Inicialmente contiene el carácter nulo (#0) que permite visualizar los caracteres tecleados. EcLowerCase: todas las mayúsculas a minúsculas. Align MaxLength CharCase Modified ReadOnly PasswordChar SelStart SelLength SelText HideSelection Entornos de desarrollo 11 . Si se quiere utilizar. Tiene los mismos valores que en el componente Label. Permite conocer la primera posición de los caracteres seleccionados.Uso básico de C++ Builder © Jesús Salas Parrilla Cursor Mediante esta propiedad se elige la forma del puntero del ratón cuando éste se encuentre sobre el componente. Cuando nos interese que vuelva a tomar el valor FALSE se debe realizar en tiempo de ejecución. TRUE: el contenido de Text no puede ser modificado por el teclado pero sí puede ser modificado por el código de nuestro programa. Los valores que puede tener esta propiedad son: ecNormal: no se realiza ninguna conversión. FALSE: permanece el texto seleccionado cuando se desactiva el componente edit. No está disponible en tiempo de diseño. Cuando se modifica la primera vez toma el valor TRUE y así permanece hasta que nos interese. EcUpperCase: todas las minúsculas a mayúsculas Inicialmente contiene el valor de FALSE. FALSE: el contenido de la propiedad Text puede ser modificado por el teclado. Hay que tener en cuenta que el primer carácter por la izquierda ocupa la posición cero. Esta propiedad nos devuelve el número de caracteres selecionados Nos permite obtener el texto que se encuentra seleccionado. El carácter contenido en esta propiedad es el que se visualiza en el lugar de las letras que se pulsan. También permite cambiar el texto seleccionado por otro. TRUE: oculta la selección cuando se desactiva el componente edit. En la propiedad Text estarán los caracteres tecleados. se le tiene que dar el valor correspondiente en tiempo de ejecución. Inicialmente contiene el valor cero para indicar que en principio no existe ningún límite. Esta propiedad es de tipo integer.

pero sí se puede activar con el ratón. Eventos Significado Entornos de desarrollo 12 . Su contenido representa el orden en que se activará el componente dentro de todos los componentes existentes en la ficha. FASE: el componente no se puede activar mediante la tecla tabulador. TRUE: permite que el componente sea activado con la tecla tabulador. Todo el texto seleccionado es copiado en el portapapeles y eliminado del componente que se está editando. En la ventana de diálogo que se abre se pueden ordenar los componentes según el criterio que el programador considere oportuno. Estas propiedades pueden tomar uno de los dos valores TRUE o FALSE. ParentCtl3D. FALSE: cuando se activa el componente permanece como se dejó antes de perder la activación. Elimina todo el texto del componente. Cuando ParentColor contiene el valor verdad quiere decir que la propiedad Color del componente Edit hereda los valores de la propiedad Edit del componente contenedor. Todo el texto seleccionado es copiado en el portapapeles. Este orden de activación se puede variar con la opción Tab Order del menú emergente que aparece al pulsar con el botón derecho sobre la ficha. ParentFont. ParentShowHint Métodos SelectAll ClearSelection Clear CopyToClipboard CutToClipboard Significado Selecciona todo el texto existente en el componente. TabStop TabOrder ParentColor. Cuando está a falso quiere decir que el componente actual tendrá sus propios valores independientes del componente contenedor.Uso básico de C++ Builder © Jesús Salas Parrilla AutoSelect TRUE: cada vez que se active el componente edit se selecciona todo el texto. Elimina todo el texto seleccionado en ese momento.

Esta propiedad contiene la cadena de caracteres que se visualiza con él. Las propiedades más usuales son: Propiedades Name Caption Significado Contiene un identificador mediante el cual se identifica el objeto. Botones (Button) Este componente tiene varias propiedades en común con los componentes vistos hasta ahora. Si contiene el valor FALSE. el botón se desactiva y el código asociado no se ejecuta aun cuando se intente pulsar dicho botón. cuando en una ficha existen varios botones. es decir. En una ficha solamente puede existir un botón con el valor True en esta propiedad. Se ejecutará cuando deje de ser el componente activo.Uso básico de C++ Builder © Jesús Salas Parrilla OnMouseDown. OnMouseMove. al pulsar la tecla <Intro> se ejecutará el evento OnClick del botón que tenga esta propiedad a verdad. Cada vez que se inserte o elimine un carácter se ejecutará este evento. TRUE: este botón se hace el botón por defecto. OnKeyPress. Enabled Font Default Entornos de desarrollo 13 . Mediante esta propiedad se le puede dar formato al texto que se visualiza y contenido en la propiedad Caption. Cuando contiene el valor TRUE el botón está activo y se pueden ejecutar las acciones atribuidas a dicho botón. Se ejecuta en el momento en que el componente Edit se convierte en el control activo de la ficha. OnKeyUp OnEnter OnExit OnChange Estos eventos ya se han estudiado. OnMouseUp. La programación de este evento es muy habitual. OnKeyDown.

Al pulsar el botón se cerraría la ficha de diálogo y se devolvería el valor correspondiente a la constante elegida en esta propiedad. Esta propiedad se utiliza para construir fichas de diálogo. Constante Valor devuelto 0 idYes idNo idOk idCancel idAbort idRetry idIgnore ModalResult mrNone mrYes mrNo mrOk mrCancel mrAbort mrRetry mrIgnore Ejemplo 2b. este botón sería el que ejecutaría su evento OnClick al pulsar la tecla <Escape>. En una ficha solamente puede existir un botón con el valor True en esta propiedad.1 Enunciado Se desea construir una ficha como la siguiente: Entornos de desarrollo 14 . Seguidamente se enumeran las constantes que ésta propiedad puede tomar y los valores que devuelve al pulsar el botón.Uso básico de C++ Builder © Jesús Salas Parrilla Cancel TRUE: cuando esta propiedad es verdadera.

Siempre que se llame a esta ficha tiene que aparecer el componente Edit a foco (activado). La pulsación del botón Salir pasa el valor de idAbort. éste debe pasar a la propiedad ModalResult el valor idYes. el componente Edit sí se puede editar. Si se ha salido porque se ha pulsado el botón Aceptar. se debe tratar la causa de la salida de dicha ficha. En este caso. Después de llamar a la ficha de entrada de cadenas. hay que visualizar la cadena Ha pulsado el botón SALIR. La ficha debe tener el formato de un cuadro de diálogo y debe aparecer centrada en la pantalla. Si la salida se ha producido porque se ha pulsado el botón Cancelar. en el componente Edit de la ficha principal se debe visualizar el mensaje Ha pulsado el botón CANCELAR. se debe visualizar en el componente Edit la cadena de caracteres que contenía el componente Edit de la segunda ficha. El orden de activación de los componentes para la tecla tabulador es: BotonLeer -> BotonBorrar -> Edit1. Cuando se pulse la tecla ESCape equivale a pulsar el botón Cancelar. El componente Edit solamente debe visualizar una cadena pero no editarla.Uso básico de C++ Builder © Jesús Salas Parrilla Al pulsar el botón Borrar cadena se debe limpiar el componente Edit y dejarlo vacío. Cuando se activa la ficha se debe borrar el contenido del componente Edit. Cuando se pulse el botón Aceptar. El orden de tabulación es el siguiente: EditEntrada -> BotonAceptar -> BotonCancelar -> BotonSalir. Al pulsar el botón Leer cadena se debe llamar a la siguiente ficha: Esta ficha es también un cuadro de diálogo. Al pulsar el botón Aceptar y regresar a la ficha principal. La pulsación del botón Cancelar pasa el valor idCancel. Cuando se pulse la tecla retorno equivale a pulsar el botón Aceptar. Si se ha salido porque se ha pulsado el botón Salir. ésta queda de la siguiente forma: Entornos de desarrollo 15 .

b. 3. si ya estás en él. Pon la fuente que desees al campo de edición (ej. Salvar el proyecto. Abre el C++ Builder o. 16 puntos). c. cierra todo (File -> Close all) y pulsa File -> New -> Application. negrita. El campo de edición se llame Salida (Name = Salida). conexión de VentanaPrincipal TRUE 4. Renombra la propuesta de Project1 como Ejemplo0201. La propiedad ReadOnly de Salida debe valer TRUE para que no se pueda modificar el contenido del campo de edición. Renombra la propuesta de Unit1 como UnidadPrincipal y pulsa el botón Guardar. sigue los siguientes pasos: a.Uso básico de C++ Builder © Jesús Salas Parrilla Solución 2b.: arial. Elimina el contenido de la propiedad Text.1 1. d. Para ello. Entornos de desarrollo 16 . Crea la carpeta Ejemplo0201 en la carpeta D:\Datos\Cbuilder6\. Modifica las propiedades de la ventana (Form1) como se indica en la tabla siguiente: Propiedad BorderStyle Hint Position Valor BsDialog Prueba de ShowModal PoScreenCenter Propiedad Caption Name ShowHint Valor Prueba de ventanas. Pulsa File -> Save Project as. 2. Diseña la ventana principal según indica el enunciado de tal forma que: a.

Hacer que la propiedad TabOrder de los botones y el componente de edición quede de la siguiente forma: BotonLeerCadena=1. En el botón para leer la cadena de caracteres se deben modificar las siguientes propiedades: Name = BotonLeerCadena. BotonBorrarCadena=2 y Salida=3. Pulsa File -> new -> Form. Pulsa el icono de los disquetes para guardar las modificaciones... c. Font = Arial. se deben modificar las siguientes propiedades: Name = BotonBorrarCadena. mrYes Valor BotonAceptar 1 Arial. En el botón del medio se deben modificar las siguientes propiedades: Entornos de desarrollo 17 . 20 puntos. negrita. negrita. 9. En el botón de la izquierda se deben modificar las siguientes propiedades: Propiedad Caption Name TabOrder Aceptar Valor Propiedad Default ModalResult Font TRUE. Diseña la nueva ventana según indica el enunciado del ejemplo. Pulsa File -> Save As . 6. Caption = Leer cadena. Guardar la nueva ventana. Font = Arial. elimina el contenido de la propiedad Text. 20 puntos..Uso básico de C++ Builder © Jesús Salas Parrilla b. negrita. Modifica las propiedades de esta nueva ventana que se indica en la siguiente tabla: Propiedad BorderStyle Position Valor BsDialog PoScreenCenter Propiedad Caption Name Valor Entrada de cadenas. modifícale la propiedad Font para que quede como Arial. negrita. 1 campo Edit y tres botones. sustituye el nombre Unit1 por UnidadEntrada y pulsa el botón Guardar. 20 puntos 10. d. Aparecerá una nueva ventana vacía llamada Form1. VentanaDeLectura 7. 16 puntos. 5. Al componente label modifícale la propiedad Caption para que tome el valor "Introduce aquí la cadena de caracteres". Coloca en la ventana los siguientes componentes: 1 label. Al campo Edit llámale Entrada (Name = Entrada). 8. Crear un nuevo formulario (ventana o ficha). Caption = Borrar cadena. En el botón para borrar la cadena de caracteres del campo de edición.

13.. 3 Arial.Uso básico de C++ Builder © Jesús Salas Parrilla Propiedad Caption Name TabOrder Valor Cancelar BotonCancelar 2 Propiedad Cancel ModalResult Font TRUE. break. Pincha con el ratón sobre la ventana principal y observa que en el Object Inspector aparece el valor VentanaPrincipal. negrita. Guardar los cambios pulsando el icono de los disquetes. case mrAbort : Salida->Text="Ha pulsado el botón SALIR". haz doble clic en el botón BotonBorrarCadena y teclea el siguiente código: Salida->Text="". Pincha en File y selecciona la opción Include Unit Hdr . Para borrar la cadena del campo edit de la ventana principal. observa que se ha creado el método OnClic de dicho botón. switch (VentanaDeLectura->ModalResult) { case mrYes : Salida->Text=VentanaDeLectura->Entrada->Text. En el botón de la derecha se deben modificar las siguientes propiedades: Propiedad Caption ModalResult Font Salir MrAbort Valor Propiedad Name TabOrder Valor BotonSalir.. introduce en dicho método el siguiente código: VentanaDeLectura->ShowModal(). case mrCancel : Salida->Text="Ha pulsado el botón CANCELAR". Haz que el campo edit de la ventana de entrada de texto tome el valor de cadena vacía cada vez que se activa la ficha y que dicho componente quede a foco en dicha activación. Haz clic en la ventana de entrada de texto y observa que el Object inspector toma el valor de VentanaDeLectura. Para hacer esto sigue los siguientes pasos: a. 20 puntos 12. Entornos de desarrollo 18 . Enlazar las ventanas. 15. 20 puntos 11. Pulsa el icono de los disquetes para guardar los cambios. en la ventana Use Unit que se abre debes seleccionar la opción “UnidadEntrada” y pulsar el botón OK. break. mrCancel Valor Arial. } 14. Haz doble clic sobre el botón “LeerCadena”. negrita.. break.

dfm" TVentanaPrincipal *VentanaPrincipal. Escribe el siguiente código en el método que se ha creado: Entrada->Text="". break. d. Selecciona los eventos de dicha ventana. //--------------------------------------------------------------------------__fastcall TVentanaPrincipal::TVentanaPrincipal(TComponent* Owner) : TForm(Owner) { } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::BotonLeerCadenaClick(TObject *Sender) { VentanaDeLectura->ShowModal(). Haz doble clic en el evento OnActivate. El código de la ventana principal es el siguiente: //--------------------------------------------------------------------------#include <vcl.h" Entornos de desarrollo 19 . 16. el proyecto se compila y si no hay errores ya se puede ejecutar.h> #pragma hdrstop #include "UnidadEntradaCadenas. Ejecuta el proyecto pulsando el icono que tiene un triángulo verde. case mrAbort : Salida->Text="Ha pulsado el botón SALIR". c.h> #pragma hdrstop #include "UnidadPrincipal.Uso básico de C++ Builder © Jesús Salas Parrilla b. break.h" #include "UnidadEntradaCadenas. 17. Entrada->SetFocus(). } } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::BotonBorrarCadenaClick(TObject *Sender) { Salida->Text="". break. Guarda pulsando sobre el icono del disquete.h" //--------------------------------------------------------------------------#pragma package(smart_init) #pragma resource "*. switch (VentanaDeLectura->ModalResult) { case mrYes : Salida->Text=VentanaDeLectura->Entrada->Text. } //--------------------------------------------------------------------------- El código de la Ventana de entrada de texto es: //--------------------------------------------------------------------------#include <vcl. 18. Selecciona la opción Project del menú principal y selecciona la opción Build all Project. case mrCancel : Salida->Text="Ha pulsado el botón CANCELAR".

Entrada->SetFocus().Uso básico de C++ Builder © Jesús Salas Parrilla //--------------------------------------------------------------------------#pragma package(smart_init) #pragma resource "*. //--------------------------------------------------------------------------__fastcall TVentanaDeLectura::TVentanaDeLectura(TComponent* Owner) : TForm(Owner) { } //--------------------------------------------------------------------------void __fastcall TVentanaDeLectura::FormActivate(TObject *Sender) { Entrada->Text="". } //--------------------------------------------------------------------------- Entornos de desarrollo 20 .dfm" TVentanaDeLectura *VentanaDeLectura.

también afectan a los componentes incluidos dentro de él. esta propiedad contendría la cadena que se quiera visualizar. como desplazamientos. Se ruega jugar con estas 4 propiedades para coger práctica en el aspecto visual. se debe cortar y luego pegar dentro del panel. Los paneles son los primeros componentes que se añaden a la ficha en tiempo de diseño. Si se utiliza para diseñar una barra de estado. Las propiedades más usuales del componente son: Propiedades Name Significado Contiene un identificador mediante el cual se identifica el objeto. BevelOuter Constante bvNone bvLowered bvRaised Significado Sin ningún efecto Hundido Resaltado BevelWidth Esta propiedad contiene un valor numérico entero positivo que indica la anchura del efecto producido por las dos propiedades anteriores. se establece una nueva relación padre-hijo entre el contenedor y los componentes que alberga. copias y eliminaciones. Esta propiedad contiene la cadena de caracteres que se visualiza con él.Uso básico de C++ Builder © Jesús Salas Parrilla Panel Es un componente pensado especialmente para agrupar una serie de componentes que se desea que tengan alguna relación entre ellos. El valor de esta propiedad establece el ancho del borde del panel. Las operaciones realizadas con el panel en la fase de diseño. Normalmente se suele vaciar si el componente se utiliza como un contenedor. fondos. barras de estado. BorderWidth Entornos de desarrollo 21 . Estas propiedades pueden tomar cualquiera de los siguientes valores de constantes: Caption BevelInner. etc. Si existe algún componente en la ficha que se quiere forme parte del panel. Cuando se incluyen componentes en componentes de contenedor. Este control se suele utilizar para la creación de barras de herramientas personalizadas.

Obligatorio la entrada de un carácter alfabético. Permite la entrada de un carácter numérico o de signo. Separador de fechas. Obligatorio la entrada de un carácter numérico. Desactiva la función de los dos caracteres anteriores. Significado Obligatorio entrar un carácter. Separador interno de la máscara. Permite la entrada de un carácter. Los caracteres siguientes aparecerán en mayúsculas. los cuales tienen un significado específico: Carácter C c A a L l 0 9 # < > <> \ : / . EditText Entornos de desarrollo 22 . Permite la entrada de un carácter numérico. Esta propiedad que es de sólo lectura.Uso básico de C++ Builder © Jesús Salas Parrilla MaskEdit Este componente es idéntico al componente Edit si no se establece ninguna máscara de control. Las máscaras se construyen a partir de la siguiente tabla de caracteres. Permite la entrada de un carácter alfabético. Interpreta el carácter siguiente como no especial. Esta propiedad permite diseñar máscaras según las necesidades del programador. Permite la entrada de un carácter alfanumérico. Las propiedades de éste componente más fundamentales son: Propiedades Significado Contiene una cadena de caracteres que representa la máscara y algunos de ellos tienen un significado especial. Obligatorio entrar un carácter alfanumérico. Representa un espacio en blanco. Los caracteres siguientes aparecerán en minúsculas. Separador de horas y minutos. contiene en cada momento el texto introducido junto con la máscara. EditMask Text Esta propiedad contendrá los caracteres tecleados con formato o sin formato dependiendo de si la opción Save Literal Characters en el cuadro de diálogo Input Mask Editor esté activada o no respectivamente.

Uso básico de C++ Builder © Jesús Salas Parrilla El componente Image Este componente se utiliza para poner imágenes sobre la ficha. TRUE: el área del componente se adapta a la dimensión de la imagen. La selección del tipo de botón se realiza en esta propiedad. TRUE: la imagen se adapta al área del componente. Los valores que puede tomar esta propiedad son: Constante bkOk Botón Kind bkCancel bkYes bkNo Entornos de desarrollo 23 . Para que aparezca en castellano debe cambiarse esta propiedad por el valor que se desee. BitBtn Este componente es básicamente un botón que cuenta con ciertas propiedades adicionales que le permiten visualizar una imagen al lado de un texto. Las propiedades más características de este componente son: Propiedades Caption Significado Por defecto los títulos aparecen en inglés. Propiedades Picture AutoSize Stretch Significado Esta propiedad permite seleccionar el fichero de mapa de bits.

La primera de ellas será usada cuando el botón esté en estado normal. A la derecha. Indica la posición del gráfico en el interior del botón. En la parte inferior central. Número de puntos que existirán entre el borde del botón y la imagen. En el fichero que se asigna a la propiedad Glyph pueden existir hasta un máximo de 4 imágenes dispuestas una junto a la otra horizontalmente. Indica el número de gráficos distintos que se visualizarán con los distintos estados del botón. Entornos de desarrollo 24 . la tercera cuando esté pulsado y la cuarta cuando permanezca en este último estado.Uso básico de C++ Builder © Jesús Salas Parrilla bkHelp bkClose bkAbort bkRetry bkIgnore bkAll Glyph NumGlyphs Propiedad mediante la cual se selecciona el fichero donde se encuentra la imagen que se quiere visualizar. ésta tendrá distintos aspectos en los distintos estados del botón. Si solamente se adjunta una imagen. de las mismas dimensiones. la segunda cuando se halle desactivado. Spacing Margin Número de puntos que existirán entre el borde de la imagen y el texto. Esta propiedad puede tener los siguientes valores: Constante Layout BlGlyphLeft BlGlyphTop BlGlyphRight blGlyphBottom Significado A la izquierda En la parte superior central.

2 Hacer el ejemplo 2b.1 utilizando los BitBtn.Uso básico de C++ Builder © Jesús Salas Parrilla Ejemplo 2b. Utilizar una imagen en la ficha de entrada de cadena para adornar la ficha. Solución La ficha principal queda de la siguiente forma: La ventana que permite leer una cadena queda de la siguiente forma: Entornos de desarrollo 25 .

break. Entornos de desarrollo 26 . } } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::BotonBorrarCadenaClick(TObject *Sender) { Salida->Text="". //--------------------------------------------------------------------------__fastcall TVentanaPrincipal::TVentanaPrincipal(TComponent* Owner) : TForm(Owner) { } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::BotonLeerCadenaClick(TObject *Sender) { VentanaDeLectura->ShowModal().dfm" TVentanaPrincipal *VentanaPrincipal. case mrAbort : Salida->Text="Ha pulsado el botón SALIR". case mrCancel : Salida->Text="Ha pulsado el botón CANCELAR". break. } El código de la unidad UnidadEntradaCadenas queda igual que en el ejemplo 1.h> #pragma hdrstop #include "UnidadPrincipal. switch (VentanaDeLectura->ModalResult) { case mrOk : Salida->Text=VentanaDeLectura->Entrada->Text.h" //--------------------------------------------------------------------------#pragma package(smart_init) #pragma resource "*.h" #include "UnidadEntradaCadenas. break. Los valores de la propiedad ModalResult de los botones de la VentanaDeLectura son los que se muestran en la sentencia switch del código.Uso básico de C++ Builder © Jesús Salas Parrilla El código de la ventana principal queda de la siguiente forma: //--------------------------------------------------------------------------#include <vcl.

Se pueden construir grupos de este componente de tal forma que todos los elementos del grupo tienen una o varias características que les unen. CbGrayed = Indeterminado. TRUE: el estado del componente está reflejado en la propiedad State. CbChecKed = marcado. FALSE: el estado del componente está indicado por la propiedad ChecKed. Pueden existir varios de ellos seleccionados al mismo tiempo. FALSE: si no está marcado.Uso básico de C++ Builder © Jesús Salas Parrilla CheckBox Se utiliza para indicar las distintas opciones que se pueden seleccionar. Cada elemento CheckBox puede estar o no activado. AllowGrayed State Entornos de desarrollo 27 . La forma de este componente está representada en la siguiente figura por el grupo de componentes Propiedades del texto: Las propiedades de este componente más usuales son: Propiedades Caption ChecKed Significado Esta propiedad contiene la cadena de caracteres que se visualiza junto al componente. CbUnchecKed = Desmarcado. TRUE: si está marcado.

como se muestra en la siguiente figura: Las propiedades principales de RadioButton son: Name. Entornos de desarrollo 28 . La única propiedad importante de este componente es Caption. donde se introduce la cadena de caracteres que hace de título de dicho componente. se debe introducir el componente RadioButton. Un ejemplo son los componentes que están introducidos en los grupos de componentes Tipos de letras y Puntos. Si se cambia de posición el componente. GroupBox Este componente tiene como finalidad la de agrupar otros componentes que tienen características comunes y necesitan un mismo tipo de control. esta propiedad debe estar vacía. Caption y ChecKed. todos los componentes contenidos dentro de él se verán desplazados con él. Por ejemplo.Uso básico de C++ Builder © Jesús Salas Parrilla RadioButtton Cuando se quiere que solamente se pueda seleccionar uno de los componentes del grupo de componentes que se están visualizando. los componentes que hay dentro del grupo Tipos de letras son excluyentes entre ellos pero esta exclusión es independiente de la aplicada al grupo Puntos. si no se quiere que aparezca título alguno.

Cuando se selecciona la propiedad de texto Normal se deben deseleccionar el resto de las propiedades de texto. Add. Indica el número de columnas en las que se va a visualizar la lista de botones de radio. Debe visualizar en el campo (componente) label más inferior el texto que está introducido en el campo edit. etc. Añadir. tachado y subrayado). es decir. el valor 1 es para el segundo y así sucesivamente. el componente GroupBox no aporta información sobre este suceso. para ello. Propiedades del texto y Puntos. Style es una propiedad de tipo conjunto con los valores (cursiva. Sobre esta lista de cadenas se pueden realizar operaciones tales como: Insertar. Dicho texto se debe visualizar según la selección que se haya hecho en Tipos de letras. Para ver la implementación de las propiedades del texto se debe consultar la ayuda del C++ Builder en Style para la VCL. es un objeto cuya estructura es una lista de cadenas. El aspecto de la ventana de la aplicación debe ser parecido al siguiente: Entornos de desarrollo 29 . con los métodos Insert. se dispone del componente RadioGroup.Uso básico de C++ Builder © Jesús Salas Parrilla RadioGroup A veces es necesario saber cuál de los botones de radio ha sido seleccionado. Borrar. Delete. El valor 0 indica que está seleccionado el primer botón de radio de la lista. Este nuevo componente permite añadir o insertar botones de radio al grupo en tiempo de ejecución. negrita. Las propiedades más importantes son: Propiedades Caption Significado Esta propiedad contiene la cadena de caracteres que se visualiza con el componente. El valor –1 indica que no hay ninguno seleccionado. la exclusión de los botones de radio en los dos grupos no es independiente. Estas operaciones se realizan con los métodos Add e Insert de la propiedad Items. Si existen dos RadioGroup con botones de radio. etc. Columns Items ItemIndex Ejemplo 2b.3 Hacer una aplicación que muestre la ventana anterior. Esta propiedad es de tipo Tstrings. Esta propiedad indica el orden del botón de radio que ha sido seleccionado.

Entornos de desarrollo 30 . } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::EntradaChange(TObject *Sender) { Salida->Caption=Entrada->Text.h" //--------------------------------------------------------------------------#pragma package(smart_init) #pragma resource "*.dfm" TVentanaPrincipal *VentanaPrincipal.Uso básico de C++ Builder © Jesús Salas Parrilla Solución //--------------------------------------------------------------------------#include <vcl. //--------------------------------------------------------------------------__fastcall TVentanaPrincipal::TVentanaPrincipal(TComponent* Owner) : TForm(Owner) { } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::EntradaClick(TObject *Sender) { Entrada->Text="".h> #pragma hdrstop #include "UnidadPrincipal.

} //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton5Click(TObject *Sender) { Salida->Font->Size=6. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton2Click(TObject *Sender) { Salida->Font->Name="Courier New". } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton11Click(TObject *Sender) { Salida->Font->Size=14.Uso básico de C++ Builder © Jesús Salas Parrilla } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton1Click(TObject *Sender) { Salida->Font->Name="Arial". } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton13Click(TObject *Sender) { Entornos de desarrollo 31 . } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton3Click(TObject *Sender) { Salida->Font->Name="Georgia". } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton12Click(TObject *Sender) { Salida->Font->Size=16. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton7Click(TObject *Sender) { Salida->Font->Size=9. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton4Click(TObject *Sender) { Salida->Font->Name="Times New Roman". } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton9Click(TObject *Sender) { Salida->Font->Size=11. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton10Click(TObject *Sender) { Salida->Font->Size=12. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton8Click(TObject *Sender) { Salida->Font->Size=10. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton6Click(TObject *Sender) { Salida->Font->Size=8.

} //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton20Click(TObject *Sender) { Salida->Font->Size=56. if (Normal->Checked) Normal->Checked=false.Uso básico de C++ Builder © Jesús Salas Parrilla Salida->Font->Size=18. if (Tachado->Checked) Tachado->Checked=false. } } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::CursivaClick(TObject *Sender) { if (Cursiva->Checked) { Salida->Font->Style=Salida->Font->Style << fsItalic. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton21Click(TObject *Sender) { Salida->Font->Size=72. if (Subrayado->Checked) Subrayado->Checked=false. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton17Click(TObject *Sender) { Salida->Font->Size=32. } else Salida->Font->Style=Salida->Font->Style >> fsItalic. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton14Click(TObject *Sender) { Salida->Font->Size=20. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton19Click(TObject *Sender) { Salida->Font->Size=48. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton15Click(TObject *Sender) { Salida->Font->Size=24. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton16Click(TObject *Sender) { Salida->Font->Size=26. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton18Click(TObject *Sender) { Salida->Font->Size=36. if (Negrita->Checked) Negrita->Checked=false. } Entornos de desarrollo 32 . if (Cursiva->Checked) Cursiva->Checked=false. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::NormalClick(TObject *Sender) { if (Normal->Checked) { Salida->Font->Style=TFontStyles().

if (Normal->Checked) Normal->Checked=false. } else Salida->Font->Style=Salida->Font->Style >> fsUnderline. if (Normal->Checked) Normal->Checked=false. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::SubrayadoClick(TObject *Sender) { if (Subrayado->Checked) { Salida->Font->Style=Salida->Font->Style << fsUnderline. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::TachadoClick(TObject *Sender) { if (Tachado->Checked) { Salida->Font->Style=Salida->Font->Style << fsStrikeOut.Uso básico de C++ Builder © Jesús Salas Parrilla //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::NegritaClick(TObject *Sender) { if (Negrita->Checked) { Salida->Font->Style=Salida->Font->Style << fsBold. } //--------------------------------------------------------------------------- Entornos de desarrollo 33 . } else Salida->Font->Style=Salida->Font->Style >> fsStrikeOut. if (Normal->Checked) Normal->Checked=false. } else Salida->Font->Style=Salida->Font->Style >> fsBold.

FALSE: los elementos se muestran en el orden en que se añaden a la lista.Uso básico de C++ Builder © Jesús Salas Parrilla ListBox Este componente se utiliza para almacenar una lista de cadenas que pueden estar ordenadas o no. Esta propiedad es de tipo integer e indica cuántos elementos están marcados o seleccionados en un instante determinado. Añadir. TRUE: la selección de los elementos se realiza con las teclas <Mayúsculas> y <Control> junto con el botón izquierdo del ratón. etc. TRUE: permite visualizar los elementos completamente en vez de la parte superior o inferior del texto. es un objeto cuya estructura es una lista de cadenas. el valor 1 es para la segunda y así sucesivamente. con los métodos Insert. Delete. El elemento seleccionado ocupa un lugar dentro de la lista que viene indicado por la propiedad ItemIndex. La propiedad Items es la que contiene los elementos de la lista. Esta propiedad indica el orden de la cadena que ha sido seleccionada. Add. TRUE: ordena automáticamente la lista de cadena. etc. FALSE: indica que solamente puede haber un elemento seleccionado en un instante determinado. Esta propiedad es de tipo Tstrings. De dicha lista se selecciona un elemento o cadena que es con el que se va a trabajar. El valor 0 indica que está seleccionado la primera cadena de la lista. Sobre esta lista de cadenas se pueden realizar operaciones tales como: Insertar. es decir. El valor –1 indica que no hay ninguna seleccionada. Items ItemIndex Sorted IntegralHeight MultiSelect ExtendedSelect SelCount Entornos de desarrollo 34 . Borrar. TRUE: en un instante determinado pueden existir varios elementos de la lista seleccionados. Las propiedades más importantes son: Propiedades Columns Significado Indica el número de columnas en las que se va a visualizar la lista de cadenas. FALSE: la selección se realiza con el botón izquierdo del ratón.

Entornos de desarrollo 35 . lbOwnerDrawVariable Cada elemento es distinto y tiene una altura variable. si no está seleccionado su correspondiente posición en Selected contiene el valor FALSE. Esta propiedad se utiliza para indicar si el componente va a almacenar una lista de cadenas o de otros objetos. Esta propiedad puede tomar tres valores: Style Constante lbStandard lbOwnerDrawFixed Tipo de elemento Todos los elementos son cadenas. Contiene tantos elementos booleanos como elementos existen en la lista. Esta propiedad tiene efecto siempre y cuando la propiedad Style contenga el valor de lbOwnerDrawFixed. ItemHeight Altura en puntos de los elementos de la lista.Uso básico de C++ Builder © Jesús Salas Parrilla Selected Propiedad de tipo tabla de booleanos. Cuando un elemento de la lista está seleccionado su correspondiente elemento de Selected contiene el valor de TRUE. Cada elemento es distinto pero con una altura fija.

En el mismo instante que se selecciona una fuente debe aplicarse su efecto en el texto de la etiqueta (label) más baja.dfm" TVentanaPrincipal *VentanaPrincipal. Para enlazar este componente hay que tener en cuenta que las fuentes que se van a visualizar tienen que ser asignadas a la propiedad Items y estas fuentes son heredadas del componente Screen.h> #pragma hdrstop #include "UnidadPrincipal. La lista de fuentes debe aparecer ordenada. //--------------------------------------------------------------------------- Entornos de desarrollo 36 .4 Modificar el ejercicio anterior para que en lugar del grupo Tipos de letras.Uso básico de C++ Builder © Jesús Salas Parrilla Ejemplo 2b. este grupo se implemente con una lista ListBox donde aparezcan todas las fuentes de letras que contenga el ordenador en ese momento.h" //--------------------------------------------------------------------------#pragma package(smart_init) #pragma resource "*. El aspecto que tiene que presentar la aplicación es el siguiente: Solución //--------------------------------------------------------------------------#include <vcl.

} //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton8Click(TObject *Sender) { Salida->Font->Size=10. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton5Click(TObject *Sender) { Salida->Font->Size=6. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton7Click(TObject *Sender) { Salida->Font->Size=9.Uso básico de C++ Builder © Jesús Salas Parrilla __fastcall TVentanaPrincipal::TVentanaPrincipal(TComponent* Owner) : TForm(Owner) { } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::EntradaClick(TObject *Sender) { Entrada->Text="". } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton12Click(TObject *Sender) { Salida->Font->Size=16. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton6Click(TObject *Sender) { Salida->Font->Size=8. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton13Click(TObject *Sender) { Salida->Font->Size=18. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::EntradaChange(TObject *Sender) { Salida->Caption=Entrada->Text. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton9Click(TObject *Sender) { Salida->Font->Size=11. } Entornos de desarrollo 37 . } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton10Click(TObject *Sender) { Salida->Font->Size=12. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton14Click(TObject *Sender) { Salida->Font->Size=20. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton11Click(TObject *Sender) { Salida->Font->Size=14.

} else Salida->Font->Style=Salida->Font->Style >> fsItalic. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton17Click(TObject *Sender) { Salida->Font->Size=32. if (Negrita->Checked) Negrita->Checked=false. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::NegritaClick(TObject *Sender) { if (Negrita->Checked) { Salida->Font->Style=Salida->Font->Style << fsBold. if (Normal->Checked) Normal->Checked=false. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton20Click(TObject *Sender) { Salida->Font->Size=56. Entornos de desarrollo 38 . } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton21Click(TObject *Sender) { Salida->Font->Size=72. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::NormalClick(TObject *Sender) { if (Normal->Checked) { Salida->Font->Style=TFontStyles(). if (Cursiva->Checked) Cursiva->Checked=false. if (Tachado->Checked) Tachado->Checked=false. if (Subrayado->Checked) Subrayado->Checked=false. } } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::CursivaClick(TObject *Sender) { if (Cursiva->Checked) { Salida->Font->Style=Salida->Font->Style << fsItalic. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton16Click(TObject *Sender) { Salida->Font->Size=26. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton18Click(TObject *Sender) { Salida->Font->Size=36. if (Normal->Checked) Normal->Checked=false.Uso básico de C++ Builder © Jesús Salas Parrilla //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton15Click(TObject *Sender) { Salida->Font->Size=24. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton19Click(TObject *Sender) { Salida->Font->Size=48.

} //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::TachadoClick(TObject *Sender) { if (Tachado->Checked) { Salida->Font->Style=Salida->Font->Style << fsStrikeOut. } else Salida->Font->Style=Salida->Font->Style >> fsStrikeOut. } else Salida->Font->Style=Salida->Font->Style >> fsUnderline. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::SubrayadoClick(TObject *Sender) { if (Subrayado->Checked) { Salida->Font->Style=Salida->Font->Style << fsUnderline. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton1Click(TObject *Sender) { Salida->Font->Size=102. Salida->Caption="". } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::FormActivate(TObject *Sender) { TipoTexto->Items=Screen->Fonts. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::TipoTextoClick(TObject *Sender) { Salida->Font->Name=TipoTexto->Items->Strings[TipoTexto->ItemIndex].Uso básico de C++ Builder © Jesús Salas Parrilla } else Salida->Font->Style=Salida->Font->Style >> fsBold. } //--------------------------------------------------------------------------- Entornos de desarrollo 39 . if (Normal->Checked) Normal->Checked=false. if (Normal->Checked) Normal->Checked=false.

Campo de edición sin lista.Uso básico de C++ Builder © Jesús Salas Parrilla ComboBox Las dos anteriores listas no permitían editar un elemento. Lista sin campo de edición. Elementos distintos con altura variable. Esta propiedad contendrá el texto del elemento seleccionado. En este tipo de listas no es posible seleccionar más de un elemento en un instante determinado. Por influencia de la herencia. Entornos de desarrollo 40 . que es una combinación de los componentes ListBox y Edit. Elementos distintos con altura fija. las propiedades de este nuevo componente serán la suma de las propiedades de los anteriores más unas nuevas que le caracterizan. Estas propiedades son: Propiedades Significado Esta propiedad se utiliza para indicar el estilo de componente que se va a utilizar. DropDownCount Text Contiene el número de líneas máximo que se visualizarán simultáneamente cuando se despliegue la lista. Esta propiedad puede tomar cinco valores: Constante Style csDropDown csSimple csDropDownList csOwnerDrawFixed csOwnerDrawVariable Estilo Lista con campo de edición asociado. para que esta posibilidad se contemple se inventó el componente ComboBox.

//--------------------------------------------------------------------------__fastcall TVentanaPrincipal::TVentanaPrincipal(TComponent* Owner) : TForm(Owner) { } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::EntradaClick(TObject *Sender) { Entornos de desarrollo 41 .Uso básico de C++ Builder © Jesús Salas Parrilla Ejemplo 2b.h" //--------------------------------------------------------------------------#pragma package(smart_init) #pragma resource "*. La aplicación debe tener el siguiente aspecto: Solución //--------------------------------------------------------------------------#include <vcl.5 Modificar el ejercicio anterior de forma que se utilice la lista ComboBox en vez de ListBox.dfm" TVentanaPrincipal *VentanaPrincipal.h> #pragma hdrstop #include "UnidadPrincipal.

} //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton11Click(TObject *Sender) { Salida->Font->Size=14. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton14Click(TObject *Sender) { Salida->Font->Size=20. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton5Click(TObject *Sender) { Salida->Font->Size=6. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton13Click(TObject *Sender) { Salida->Font->Size=18. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton8Click(TObject *Sender) { Salida->Font->Size=10.Uso básico de C++ Builder © Jesús Salas Parrilla Entrada->Text="". } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton10Click(TObject *Sender) { Salida->Font->Size=12. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton12Click(TObject *Sender) { Salida->Font->Size=16. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton6Click(TObject *Sender) { Salida->Font->Size=8. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton7Click(TObject *Sender) { Salida->Font->Size=9. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton9Click(TObject *Sender) { Salida->Font->Size=11. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton15Click(TObject *Sender) { Salida->Font->Size=24. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton16Click(TObject *Sender) Entornos de desarrollo 42 . } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::EntradaChange(TObject *Sender) { Salida->Caption=Entrada->Text.

if (Tachado->Checked) Tachado->Checked=false. } else Salida->Font->Style=Salida->Font->Style >> fsBold. if (Normal->Checked) Normal->Checked=false. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton18Click(TObject *Sender) { Salida->Font->Size=36. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton20Click(TObject *Sender) { Salida->Font->Size=56. if (Subrayado->Checked) Subrayado->Checked=false. if (Normal->Checked) Normal->Checked=false. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton21Click(TObject *Sender) { Salida->Font->Size=72. if (Cursiva->Checked) Cursiva->Checked=false. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton17Click(TObject *Sender) { Salida->Font->Size=32.Uso básico de C++ Builder © Jesús Salas Parrilla { Salida->Font->Size=26. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::NegritaClick(TObject *Sender) { if (Negrita->Checked) { Salida->Font->Style=Salida->Font->Style << fsBold. } } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::CursivaClick(TObject *Sender) { if (Cursiva->Checked) { Salida->Font->Style=Salida->Font->Style << fsItalic. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton19Click(TObject *Sender) { Salida->Font->Size=48. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::TachadoClick(TObject *Sender) { if (Tachado->Checked) Entornos de desarrollo 43 . if (Negrita->Checked) Negrita->Checked=false. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::NormalClick(TObject *Sender) { if (Normal->Checked) { Salida->Font->Style=TFontStyles(). } else Salida->Font->Style=Salida->Font->Style >> fsItalic.

Uso básico de C++ Builder © Jesús Salas Parrilla { Salida->Font->Style=Salida->Font->Style << fsStrikeOut. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton1Click(TObject *Sender) { Salida->Font->Size=102. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::TipoTextoChange(TObject *Sender) { Salida->Font->Name=TipoTexto->Text. if (Normal->Checked) Normal->Checked=false. Salida->Caption="". if (Normal->Checked) Normal->Checked=false. } //--------------------------------------------------------------------------- Entornos de desarrollo 44 . } else Salida->Font->Style=Salida->Font->Style >> fsStrikeOut. } else Salida->Font->Style=Salida->Font->Style >> fsUnderline. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::FormActivate(TObject *Sender) { TipoTexto->Items=Screen->Fonts. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::SubrayadoClick(TObject *Sender) { if (Subrayado->Checked) { Salida->Font->Style=Salida->Font->Style << fsUnderline.

TRUE: una cadena o línea de texto ocupa varias líneas del componente Memo. un objeto. WordWrap Entornos de desarrollo 45 . Método que permite eliminar una determinada línea de texto. Método que permite insertar una línea en una determinada posición. el componente Edit no cubre esta necesidad y se debe utilizar el componente Memo. En tiempo de ejecución se puede tratar esta propiedad como si se tratase de una matriz en la que cada elemento es una línea de texto. Las propiedades típicas de este componente son: Propiedades Significado El texto del componente se estructura en múltiples cadenas que están contenidas en esta propiedad. Lines->SaveToFile Método que permite guardar en un fichero de texto el contenido de Memo. Esta propiedad es. a su vez.Uso básico de C++ Builder © Jesús Salas Parrilla Memo Cuando el texto que debe introducir el usuario es extenso. Lines Lines->Count Lines->Add Lines->Insert Lines->Delete Lines->Move Lines->Exchange Lines->LoadFromFile Método que permite leer texto de un archivo de texto. Método de Lines que permite añadir texto al componente Memo. La mayor parte de las propiedades del componente Edit también las posee el componente Memo. Propiedad de Lines que contiene el número de líneas que existen en cada momento en el componente Memo. La primera línea tiene como índice el cero. Este nuevo componente puede contener múltiples líneas de texto. FALSE: una línea de texto solamente ocupa una línea del componente Memo. Método que permite mover una línea de posición. Método que permite intercambiar dos líneas de texto.

Tiene el mismo efecto que la anterior propiedad pero con la tecla de retorno. Horizontal Vertical Ambas WantTabs TRUE: cuando el componente Memo está activo y se pulsa la tecla de tabulación se produce un salto de tabulación. FALSE: al pulsar la tecla de tabulación se le quita el control al componente Memo.Uso básico de C++ Builder © Jesús Salas Parrilla Esta propiedad permite que aparezca o no desplazamiento. Los valores de esta propiedad son: ScrollBars barras de Constante SsNone SsHorizontal SsVertical ssBoth Tipo de barra Ninguna barra de desplazamiento. WantReturns Entornos de desarrollo 46 .

h" //--------------------------------------------------------------------------#pragma package(smart_init) #pragma resource "*.Uso básico de C++ Builder © Jesús Salas Parrilla Ejemplo 2b.6 Hacer el mismo ejemplo anterior pero utilizando el componente Memo para introducir el texto y darle formato.h> #pragma hdrstop #include "UnidadPrincipal. //--------------------------------------------------------------------------__fastcall TVentanaPrincipal::TVentanaPrincipal(TComponent* Owner) Entornos de desarrollo 47 . La ventana debe tener un aspecto parecido al siguiente: Solución //--------------------------------------------------------------------------#include <vcl.dfm" TVentanaPrincipal *VentanaPrincipal. Poner un botón para borrar el contenido del componente Memo.

} //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton11Click(TObject *Sender) { Salida->Font->Size=14. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton7Click(TObject *Sender) { Salida->Font->Size=9. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton8Click(TObject *Sender) { Salida->Font->Size=10. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton6Click(TObject *Sender) { Salida->Font->Size=8.Uso básico de C++ Builder © Jesús Salas Parrilla : TForm(Owner) { } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton5Click(TObject *Sender) { Salida->Font->Size=6. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton15Click(TObject *Sender) { Salida->Font->Size=24. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton10Click(TObject *Sender) { Salida->Font->Size=12. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton9Click(TObject *Sender) { Salida->Font->Size=11. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton16Click(TObject *Sender) { Salida->Font->Size=26. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton13Click(TObject *Sender) { Salida->Font->Size=18. } //--------------------------------------------------------------------------- Entornos de desarrollo 48 . } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton14Click(TObject *Sender) { Salida->Font->Size=20. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton12Click(TObject *Sender) { Salida->Font->Size=16.

} else Salida->Font->Style=Salida->Font->Style >> fsItalic. } else Salida->Font->Style=Salida->Font->Style >> fsBold. if (Subrayado->Checked) Subrayado->Checked=false. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::TachadoClick(TObject *Sender) { if (Tachado->Checked) { Salida->Font->Style=Salida->Font->Style << fsStrikeOut. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton19Click(TObject *Sender) { Salida->Font->Size=48.Uso básico de C++ Builder © Jesús Salas Parrilla void __fastcall TVentanaPrincipal::RadioButton17Click(TObject *Sender) { Salida->Font->Size=32. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::NormalClick(TObject *Sender) { if (Normal->Checked) { Salida->Font->Style=TFontStyles(). } Entornos de desarrollo 49 . if (Normal->Checked) Normal->Checked=false. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton20Click(TObject *Sender) { Salida->Font->Size=56. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton21Click(TObject *Sender) { Salida->Font->Size=72. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::NegritaClick(TObject *Sender) { if (Negrita->Checked) { Salida->Font->Style=Salida->Font->Style << fsBold. if (Tachado->Checked) Tachado->Checked=false. if (Normal->Checked) Normal->Checked=false. if (Negrita->Checked) Negrita->Checked=false. if (Normal->Checked) Normal->Checked=false. } } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::CursivaClick(TObject *Sender) { if (Cursiva->Checked) { Salida->Font->Style=Salida->Font->Style << fsItalic. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton18Click(TObject *Sender) { Salida->Font->Size=36. if (Cursiva->Checked) Cursiva->Checked=false.

} //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::TipoTextoChange(TObject *Sender) { Salida->Font->Name=TipoTexto->Text. Salida->Text="". } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::SubrayadoClick(TObject *Sender) { if (Subrayado->Checked) { Salida->Font->Style=Salida->Font->Style << fsUnderline. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::BotonBorrarClick(TObject *Sender) { Salida->Clear(). } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::RadioButton1Click(TObject *Sender) { Salida->Font->Size=102. if (Normal->Checked) Normal->Checked=false. } //--------------------------------------------------------------------------void __fastcall TVentanaPrincipal::FormActivate(TObject *Sender) { TipoTexto->Items=Screen->Fonts. } else Salida->Font->Style=Salida->Font->Style >> fsUnderline.Uso básico de C++ Builder © Jesús Salas Parrilla else Salida->Font->Style=Salida->Font->Style >> fsStrikeOut. } //--------------------------------------------------------------------------- Entornos de desarrollo 50 .

1 Hacer una aplicación en Delphi que pida la introducción de una fecha a través de un componente TEdit y cuando se pulse el botón Aceptar muestre en un componente TLabel el día de la semana correspondiente a dicha fecha. Se deben contar la cantidad de años bisiestos y mostrarla en la ventana. de tal forma que si se introduce una cadena que no es un número entero se debe mostrar un mensaje de error. El más pequeño se utilizará como año inicial y el mayor se utilizará como año final. El programa debe calcular los años que son bisiestos comprendidos entre los dos números anteriores. La ventana puede tener el siguiente formato: Ejercicio 2b.2 Hacer una aplicación en Delphi que pida la introducción de dos números enteros positivos. Los años que son bisiestos se deben introducir en un componente TListBox.Uso básico de C++ Builder © Jesús Salas Parrilla Ejercicios Ejercicio 2b. Se deben hacer validaciones. Un formato de esta ventana podría ser: Entornos de desarrollo 51 .

de tal forma que si se introduce una cadena que no es un número entero se debe mostrar un mensaje de error. Un formato de esta ventana podría ser: Ejercicio 2b.3 Hacer una aplicación en Delphi que pida la introducción de dos números enteros positivos. Utilizar componentes TListBox para mostrar los números que son amigos y sus divisores.Uso básico de C++ Builder © Jesús Salas Parrilla Ejercicio 2b. El formato de la ventana debe ser el siguiente: Entornos de desarrollo 52 . Los años que son jacobeos los debe mostrar en un componente TListBox. El programa debe calcular los años jacobeos que hay entre el año inicial y el año final.4 Hacer un programa en Delphi que pida la introducción de un número entero positivo y calcule todos los números amigos que hay entre el uno y el número introducido. El más pequeño se utilizará como año inicial y el mayor se utilizará como año final. Cuando se seleccione un número deben aparecer sus divisores en el componente TListBox destinado a tal cuestión. Se deben hacer validaciones. Un número entero es amigo de otro cuando la suma de todos los divisores del primer número da como resultado el segundo y la suma de todos los divisores del segundo número da como resultado el primer número.

Los factoriales se deben mostrar en un componente TMemo.5 Hacer un programa en Delphi que muestre el factorial de los 33 primeros números enteros y el factorial del número entero mayor que 33 que se introduzca en un componente TEdit.Uso básico de C++ Builder © Jesús Salas Parrilla Ejercicio 2b. También debe mostrar los tiempos inicial. final y diferencia de la ejecución del bucle de cálculo. El formato de la ventana debe ser el siguiente: Entornos de desarrollo 53 .