Los componentes son los elementos u objetos mas básicos de la programación visual moderna, con ellos se construyen las diversas aplicaciones que se ejecutan bajo un ambiente Windows.
En esta UNIDAD, se pretende profundizar en el estudio de estos elementos básicos de construcción de programas, en esta UNIDAD se pretende:
* Comprender los conceptos de componentes , clases y objetos, tanto visuales como no visuales.
* Instalación y mantenimiento de nuevos componentes visuales.
* Creación e instalación de componentes visuales.
* Creación e instalación de componentes no visuales.
TEMA 2.- C++BUILDER COMPONENTES, CLASES Y OBJETOS
Como ya se menciono anteriormente, componentes son las piezas basicas, con las que se arma, construye y diseña, una aplicacion cualesquiera.
Como se explico al principio del libro, la programacion moderna o actual, es de tipo visual, pero su fondo o esencia es la llamada programacion orientada a objetos.
En orden o principio, recordar que todo en la vida o el universo, no es mas que un objeto de cualquier clase o naturaleza ya sea material o inmaterial, todos los objetos tienen sentido, forma, tamaño y un gran conjunto de caracteristicas que permiten diferenciarlos, pero tambien clasificarlos y agruparlos, entre si.
Desde este punto de vista un programa en ejecucion o un sistema de información, se puede considerar como un conjunto de objetos que como en la vida real interactuan entre si, creandose entre ellos ya se una serie de relaciones e interacciones, programacion de punta o avanzada ya toma en cuenta, la naturaleza dinamica de los propios objetos(esto es llamada concurrencia, es decir la capacidad de existir en forma independiente y a la vez que el resto de los objetos del sistema, esto se estudia mas a fondo en el siguiente capitulo de este libro).
Sin embargo, su manifestacion programatica de los objetos, en los lenguajes modernos de programacion, son las llamadas clases, es decir una clase es la representacion simbolica y computacional de toda una serie de objetos con caracteristicas comunes entre si, por eso existe la clase gatos, empleados, arboles, listas, reportes, vectores, etc, es decir pueden existir tantas clases como objetos existen en el universo y cada clase contiene todos los objetos con caraceristicas comunes entre si, o de la misma categoria o clasificaacion, un ejemplo de una clase en un lenguaje de programacion es:
Class gatos{
public:
int edadgato;
AnsiString nombregato;
maullar();
capturardatosgato();
}gatonegro, garfield, gatotijuanense;
gatos::maullar(){ cin»“miauuuu”;}
gatos::capturardatos(){ cin»“dame edad”; cout«edad; }
Como se observa, comprender, localizar y programar todas las carecteristicas o atributos de una sola clase, es una tarea bastante grande, mientras que los comportamientos ( metodos en oop) es todavia mas laborioso y complejo y si agregamos la interaccion natural existente entre objetos ( los llamados eventos en oop), garantiza que existiran la necesidad de ingenieros de software por mucho tiempo en el futuro.
Observar del ejemplo, que del conjunto de objetos que representa la clase, se derivan instancias(gatonegro, garfield) individuales de esa clase, desgraciadamente a esas instancias individuales tambien se les conoce como objetos y esto manifiesta o conduce a la confusion entre las dos interpretaciones de el concepto objeto, en su sentido generico o universal y su sentido particular o programatico, como una instancia derivada de una clase, problema viejo en los ambientes de programacion.
Por ultimo un componente, se puede entender como la manifestacion visible de un objeto en un ambiente de desarrollo visual, es decir un componente no son mas que algunos aspectos o propiedades del objeto, que permiten la conceptualizacion y manipulacion de los objetos en los programas de aplicaciones visuales.
En resumen objeto→clase→componente, es la escencia o trilogia clasica en la programacion visual moderna.
TEMA 3.- C++BUILDER INSTALACION Y MANTENIMIENTO DE COMPONENTES VISUALES
En este tema, se estudia la manera de manipular, eliminar, etc, nuevos componentes y folders o paginas de nuevos componentes, usando el menu de componentes que proporciona C++Builder.
Para efectuar procesos simples con paginas y componentes ya contenidos en C++builder, usar en la barra de menu, la opcion de componentes, donde su opcion mas elemental, es “configure palette”, que muestra la siquiente ventana:
La primera ventananita, permite manipular las paginas de componentes y la segunda ventanita permite manipular los componentes, las operaciones mas elementales y a la vista son, reaacomodar el orden de paginas o componentes, solo click en ellos y luego, usar las flechas, eliminar y renombrar, para mover un componenente de una pagina a otra pagina, solo arrastrarlo a la nueva pagina y borrarlo de la antigua.
Solo recordar que al final que para que todas las operaciones indicadas se lleven a cabo, se debera reconstruir la libreria de componentes con la orden Component, Rebuild Library.
TEMA 4 INSTALACION PRACTICA DE COMPONENTES C++BUILDER
Ejemplo, un componente llamado my_panel que se encuentra en
www.nh.ultranet.com/~bsturk , (el componente se llama my_panel.zip, si no se encuentra en el lugar indicado, rastrearlo por los medios ya dichos o usar un sitio de busqueda de archivos como http://ftpsearch.ntnu.no/ftpsearch) este componente permite poner un panel con un fondo tipo wallpaper en la ventana de la aplicacion:
PROCEDIMIENTO
1.-Bajarlo de Internet y ponerlo en un directorio temporal en disco duro.
2.-Descomprimirlo, observar que deberá haber cuando menos un archivo de tipo *.pas, *.cpp, *.obj
3.-Copiar los archivos fuentes (.pas, .cpp, .obj, .res. etc.) a el folder BIN de C++Builder, si C++Builder se instalo con las opciones de default, entonces el path es c:\program files\borland\cbuilder\bin
4.- Cargar o arrancar el C++Builder.
5.- Dentro de menú principal, primero click en component.
6.- Click en Install (sale ventana Install component).
7.- Click en botón Add (sale una ventana llamada Add module).
8.- Click en botón browse (sale una ventana llamada Add component).
9.- Abajo cambiar el tipo de archivo ( Files of Type) de a .CPP o .PAS dependiendo del código fuente obtenido con el componente.
10.- Ir subiendo arriba desde el directorio de projects hasta llegar al directorio BIN.
11.- Aquí en este directorio Bin, debe existir y aparecer ahora un archivo llamado my_panel.cpp o .pas
12.- Seleccionar este ultimo archivo y click en botón open.
13.- C++Builder regresa ahora a la ventana Install Component,
14.- Click en botón OK.
15.- Empieza ahora un proceso de compilación de librerías, esperar hasta que Done=Make, click en OK, sigue reconstruyendo.
16.- Revisar que ahora en la barra de componentes, se encuentre una nueva pestaña (Samples),con sus nuevo componentes.
17.- Recordar que con opción Configure Palete y Rebuild Library, se pueden reorganizar paginas y componentes.
TEMA 5 CREACION E INSTALACION DE COMPONENTES VISUALES C++BUILDER
La herramienta mas poderosa de la programacion moderna (objeto-visual) es la capacidad increible y la manera tan sencilla de poder crear y manipular nuestros propios componentes, que seguramente seran, mucho mas faciles de usar y de entender, que los que trae de default el C++Builder o los obtenidos de Internet.
Supongase que se quiere un componente muy especializado o mas estetico, por ejemplo TRadio o TGrabadora (observar que componentes personales empiezan con la letra T, esto es una convencion), solo se tiene que :
* primero derivarlo de algún componente del C++Builder que se le parezca o sea apropiado, por ejemplo el media player.
* luego modificarle, o agregarle algunas o nuevas propiedades, esto se hace mediante código ya conocido,
* después agregarle nuevos eventos, o programarle, algún default a los ya heredados.
* al final, instalarlo en alguna de las paginas de componentes.
Notas.
1.- Todo nuevo componente visual, se debera derivar de algun componente ya creado.
2.- Todo componente hereda todas las propiedades (caracteristicas), metodos(procedimientos o funciones propios) y eventos (respuestas programadas del componente a una interacción con otro objeto o componente) del componente padre.
3.- Borland provee de una tabla, que muestra todos los componentes de caracter visual y no visual, dicha tabla es necesario conocerla, para poder localizar el componente apropiado, para derivar el componente que se esta creando.
Diagrama Simplificado de la jerarquía de componentes
* tomado de Component Writer’s Guide
* El diagrama jerárquico completo, es muy grande y muestra mas de 100 clases y objetos, es necesario conseguirlo y tenerlo a la mano.
El ejemplo será muy simple, se derivara un componente llamado miboton a partir del componente visual TButton, solo se modificaran algunas propiedades.
1.- Cargar el C++Builder
2.- File, Close All
3.- Component, new y aparece la siguiente ventana:
Class Name = miboton.
Ancestor Type= usar flechita para buscar y seleccionar TButton.
Palette Page = usar flechita para buscar y seleccionar Standar.
Click en Ok
4.- Aparece ahora el siguiente código dentro de unit1.cpp:
observar las cuatro partes o áreas bien diferenciadas entre si y la notas (encerradas entre {{}} personales puestas ahí para su aclaración.
//----------------------------------------------------------------
{{ primera área, solo código para incluir la librería de componentes
visuales(vcl.h) y una librería de interfase(mas adelante se explica que
significa(ver Pascal)) llamada unit.h }}
#include
//----------------------------------------------------------------
{{ segunda parte, código de C++Builder para verificar que el componente
creado miboton, es derivado de un componente valido y visual existente,
en este caso de TButton }}
static inline miboton *ValidCtrCheck()
{
return new miboton(NULL);
}
//----------------------------------------------------------------
{{ tercera área y la mas importante, es el constructor (primer
procedimiento o función que se ejecuta cuando se usa este componente, es
decir se activa automáticamente en el momento de ponerlo en Form1), es
decir es en esta parte donde se pueden agregar las modificaciones a las
propiedades que se pretenden hacer, posteriormente desde aquí también se
puede enlazar o llamar o invocar a otros métodos propios }}
__fastcall miboton::miboton(TComponent* Owner): TButton(Owner)
{
}
//----------------------------------------------------------------
{{ cuarta área, código de C++Builder para registrar nuestro componente en
la pagina "Standar" }}
namespace Unit1
{void __fastcall Register()
{
TComponentClass classes[1] = {__classid(miboton)};
RegisterComponents("Standard", classes, 0);
}
}
//----------------------------------------------------------------
Como se observa, solo se deberá usar la tercera área, solo escribir el
siguiente código dentro de las llaves que están abajo del constructor.
//----------------------------------------------------------------
__fastcall miboton::miboton(TComponent* Owner): TButton(Owner)
{
Height = Height * 2;
Width = Width * 3;
Font->Color=clGreen;
Caption = "Hola, Bienvenido a C++Builder";
}
TEMA 6: CORRECCION Y MODIFICACION DE COMPONENTES VISUALES C++BUILDER
Procedimiento:
1.- File, Close All
2.- File, Open y subir hasta el directorio Bin de C++Builder, click en miboton.cpp, para cargarlo.
3.- Corregirlo o modificarlo.
4.- File, Save
5.- File, Close All
6.- Component, Rebuild Librery
7.- Done=MaKe, entonces click OK
TEMA 7: ELIMINACION DE COMPONENTES C++BUILDER
Recordar que con la opción de Delete en configure Palette, solo se eliminan lógicamente los componentes visuales instalados.
Este procedimiento elimina completamente los componentes o paginas, para recuperar paginas se deberá reinstalar C++Builder, para recuperar componentes propios se deberán crearlos e instalarlos de nueva cuenta.
Procedimiento:
1.- File, Close All
2.- Componente, Install
3.- Seleccionar y click en la ventana derecha, la pagina o componente a remover
4.- Click en botón Remove
5.- Click en OK y empieza la compilación hasta que Done=Make y OK
6.- Cerrar Builder y con el explorer o Mycomputer de Windows ir al directorio Bin de C++Builder, buscar y eliminar los dos archivos del componente, en este ejemplo miboton.cpp y miboton.h
TEMA 8: AGREGANDO UN RECURSO BITMAP AL COMPONENTE C++BUILDER
A cada componente se le puede asociar tres tipos de recursos graficos:
a) Un bitmap.- Es un icono grafico creado para sustituir, el icono de default en la barra de componentes.
b) Un icon.- Grafico pequeño que aparece en la parte superior de un componente.(observar Form1).
c) Un cursor.- Algunos componentes tiene la propiedad de manejar un cursor diferente al default(la flechita), es posible crear cursores especiales y asignarlos al componente( si el componente tiene está propiedad), en el momento que el componente recibe el focus del programa, es decir en el momento que entra el cursor de default, se activara el nuevo cursor.
Procedimiento:
Se supone que ya esta creado e instalado el componente original, en este ejemplo miboton.cpp y miboton.h
1.- File, Close All
2.- Component, Install, seleccionar miboton.cpp, Remove, Ok, esperar hasta Done=Make, Ok
* Este paso remueve el componente con su viejo bitmap, de la paleta de cmponentes.
3.- Tools, Image Editor, que es una ventana muy parecida al paint.
4.- Dentro del editor de imagenes:
4.1.- File, new, Resource File, y aparece una nueva ventanita, que tiene como primer renglon, -Contents
4.2- Cursor sobre Contents y click derecho para un minimenu y crearle un bitmap, un icon y un cursor
4.3.- Cursor sobre bitmap y click derecho para, primerlo editarlo y segundo renombrarlo con miboton ( atención es necesario que el bitmap se llame igual que el componente)
4.4.- Cursor sobre icon y click derecho para, primero editarlo y luego renomrarlo a miboton
4.5.- Cursor sobre cursor y click derecho para, primerlo editarlo y luego renombrarlo a miboton tambien.
*Esta ventanita debe verse como lo siguiente:
4.6.- File, Save As, conmo miboton.res
4.7.- File, Exit
5.- En C++Builder:
Component, Install, Add, Browse, miboton.cpp, open, ok,
esperar a Done=Make, Ok y ya debe aparecer el componente en la paleta con su nuevo bitmap.
TEMA 9 CREACION DE COMPONENTES NO VISUALES C++BUILDER
En este temas se analiza, la creación y construcción de componentes no visuales.
La necesidad de este tipo de componentes se desprende del hecho de que existen muchas tareas de programación de carácter repetitivo a lo largo de la construcción de muchas aplicaciones, por ejemplo se manejan en 10 programas, o tareas o aplicaciones distintas el mismo conjunto de tres fórmulas matemáticas o financieras, etc.
En caso como estos, es mas conveniente crear un componente especializado en solución de dichas fórmulas y estarlo reutilizando en las diversas aplicaciones que lo ocupen.
Para realizar esto primero diseñamos la clase correspondiente, tal como el ejemplo de clases en paginas anteriores:
// declaración de la clase, sus variables y sus métodos
Class fórmulas
{
int areatriangulo( int base, int altura);
float pesosdolares (int pesos, float tipocambio);
double promedio(int calif1, int calif2);
}
// implementacion de los métodos de la clase
int formulas::areatriangulo(int base, int altura)
{ return base* altura /2 ;}
float formulas::pesosdolares(int pesos, float tipocambio)
{ return pesos/tipocambio; }
double formulas::promedio(int calif1, int calif2)
{return (calif1+calif2)/2.0 ;}
La pasamos ahora al C++Builder, el procedimiento comentado es:
Procedimiento:
1.- File, Close All
2.- Componente New,
Clase Name = fórmulas
Ancestor = TComponent
Page = Standard
* Observar que todo clase no visual, se deriva de TComponent, con esto se asegura un mínimo visual de propiedades, incluyendo un icono de default, para la barra de componentes y un par de eventos, los métodos de la clase es lo que se va a construir y programar.
3.- File Save As, fórmulas, Save
4.- A la vista queda el editor con formulas.cpp , en la parte de arriba donde dice #include
En estos dos archivos se construye la clase, la parte declarativa de la clase queda en el archivo formulas.h y la parte de implementacion o los métodos quedan en el archivo formulas.cpp, como observación en PASCAL solo se ocupa el archivo llamado unit.pas y ahí quedan juntos pero en su área apropiada las dos partes de una clase, su declaración y su implementación.
Observar el código ya generado por C++Builder de formulas.h;
//----------------------------------------------------------
#ifndef formulasH
#define formulasH
//----------------------------------------------------------
#include
#include
#include
#include
//----------------------------------------------------------
class fórmulas : public TComponent
{
prívate:
protected:
public:
__fastcall fórmulas(TComponent* Owner);
__published:
};
//----------------------------------------------------------
#endif
1.- Recordar que es en este archivo el .h donde se hace la declaración de la clase.
2.- Observar que C++Builder ya definió la clase y la hizo un descendiente publico de TComponent, esto de publico es para permitir que todos los demás componentes puedan accesar las propiedades y métodos de la clase Fórmulas.
3.- Variables, métodos( procedimientos y funciones) y propiedades que ocupe la clase fórmulas deberán declararse dentro de la llaves.
4.- Tomar nota que pueden existir cuatro tipos diferente de variables, métodos y propiedades, ellos son:
prívate: solo métodos dentro de la propia clase, tienen
acceso y pueden manipularlos.
protected: No pueden ser accesados por código fuera de la la clase, pero si por métodos de la propia clase.
public: Código externo, otras clases y métodos propios pueden accesarlos.
_published: Solo para propiedades que se quiera que aparezcan en el inspector de objetos.
5.- Para el ejemplo de la clase que se esta manejando, se escriben o mejor dicho declaran los métodos en la parte publica de la clase, como en el siguiente ejemplo
//----------------------------------------------------------------
#ifndef formulasH
#define formulasH
//----------------------------------------------------------------
#include
#include
#include
#include
//----------------------------------------------------------------
class fórmulas : public TComponent
{
prívate:
protected:
public:
__fastcall fórmulas(TComponent* Owner);
int areatriangulo( int base, int altura);
float pesosdolares (int pesos, float tipocambio);
double promedio(int calif1, int calif2);
__published:
};
//----------------------------------------------------------------
#endif
6.- La parte de implementacion, se escribe al final del archivo .cpp, como se muestra en el siguiente ejemplo.
//----------------------------------------------------------------
#include
#pragma hdrstop
#include "formulas.h"
//----------------------------------------------------------------
static inline fórmulas *ValidCtrCheck()
{
return new fórmulas(NULL);
}
//----------------------------------------------------------------
__fastcall formulas::formulas(TComponent* Owner):TComponent(Owner)
{
}
//----------------------------------------------------------------
namespace Fórmulas
{
void __fastcall Register()
{
TComponentClass classes[1] = {__classid(fórmulas)};
RegisterComponents("Standard", classes, 0);
}
}
//----------------------------------------------------------------
// implementacion de los métodos de la clase
int formulas::areatriangulo(int base, int altura)
{ return base* altura /2 ;}
float formulas::pesosdolares(int pesos, float tipocambio)
{ return pesos/tipocambio; }
double formulas::promedio(int calif1, int calif2)
{return (calif1+calif2)/2.0 ;}
* Solo se escriben los últimos renglones y en la posición indicada, es decir al final del archivo .cpp
7.- Files, Save All
8.- File, Close All
9.- Component, Install, Add, Browse, formulas.cpp, Open, Ok hasta
que Done=Make, entonces OK
* Observar el nuevo icono de fórmulas image117.jpgen la barra de componentes.
Ejemplo de aplicación:
1. Pantalla de Diseño:
b) Código
//----------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Edit3->Text=formulas1->promedio(Edit1->Text.ToInt(),
Edit2->Text.ToInt() );
}
//----------------------------------------------------------------
3. Pantalla de corrida
No hay comentarios:
Publicar un comentario