Creacion de Componentes en Borland C++ Builder: Pasos para crear un componente en Borland C++ Builder

QUE ES UN COMPONENTE NO VISUAL?

Cómo crear uno?

Se pueden establecer muchas clasificaciones para los componentes. Una de ellas es la de visuales o controles, frente a no visuales.

Un componente es visual cuando tiene una representación gráfica en tiempo de diseño y ejecución (botones, barras de scroll, cuadros de edición, etc.), y se dice no visual en caso contrario (temporizadores, cuadros de diálogo -no visibles en la fase de diseño-, etc.).

Por lo demás no existen más diferencias entre ellos, excepto, claro está, las derivadas de la visualización del componente.

Los componentes no visuales se pueden colocar en los formularios de la misma manera que los controles, aunque en este caso su posición es irrelevante.

PASOS A SEGUIR:

I) Creación de una nueva Paleta

o Acceder al menú Component

o Ir a Configurar Paletee

o Aparecerá la siguiente ventana

Presionar Botón Add, y colocar un nombre a la paleta que estoy creando, en nuestro ejemplo la paleta se llamará MiComponente.

Hacer clic en botón Aceptar.

II) Creación del Componente

o Acceder al menú Component

o Ir a New Component

o Aparecerá la siguiente ventana

o Elegir TComponent en el Edit Ancestor Type

o Colocar nombre de mi clase, en este caso se llamará Prueba.cpp en el Edit Class Name

o En Palette Page, seleccionar mi paleta creada, en este caso MiComponente

o Direcciono donde deseo guardar mi clase

III) Empezar a Programar

La clase Prueba que vemos, es un simulador de Memoria, que trabaja con datos enteros, y con un máximo de 15 datos

Código Fuente clase Prueba

Prueba.h

#ifndef PruebaH

#define PruebaH
//-------------------------------
#include
#include
#include
#include

//---------------------------------------------------------------------------
struct Data
{

String Cont;

int Next;
};
struct Mem
{
Data Dato;
int Link;
bool sw;
};

Clase Prueba.cpp

#include
#pragma hdrstop

#include "Prueba.h"
#include "Unit1.h"
#pragma package(smart_init)
//---------------------------------------------------------------------------
// ValidCtrCheck is used to assure that the components created do not have
// any pure virtual functions.
//

static inline void ValidCtrCheck(TMemoriaShi *)
{
new TPrueba(NULL);
}
//---------------------------------------------------------------------------
__fastcall TPruebai::TPrueba(TComponent* Owner)
: TComponent(Owner)
{
for (int i=0; i
{
M[i].Dato.Cont="";
M[i].Dato.Next=0;
M[i].sw=false;
M[i].Link=i+1;
}
M[Max-1].Link=-1;
Libre=0;
x=400; y=50;
}

//---------------------------------------------------------------------------
namespace Prueba
{
void __fastcall PACKAGE Register()
{
TComponentClass classes[1] = {__classid(TPrueba)};
RegisterComponents("Estruc1", classes, 0);
}
}
//---------------------------------------------------------------------------

int TPrueba::PedirEsp()
{
if(Libre==-1)
{
MessageDlg("MEMORIA LLENA!!!",mtError,TMsgDlgButtons() <<>
}
else
{
int x=Libre;
Libre=M[x].Link;
M[x].sw=true;
return x;
}
}

void TPrueba::LiberarEsp(int d)
{
if(!M[d].sw)
{
MessageDlg("ESPACIO LIBRE!!!",mtError,TMsgDlgButtons() <<>
}
else
{
M[d].Link=Libre;
M[d].sw=false;
Libre=d;
}
}

void TPrueba::AsignarCont(int d, String n)
{
M[d].Dato.Cont=n;
M[d].sw=true;
}

void TPrueba::AsignarNext(int d, int n)
{
M[d].Dato.Next=n;
M[d].sw=true;
}

String TPrueba::Get_Cont(int d)
{
return M[d].Dato.Cont;
}

int TPrueba::Get_Next(int d)
{
return M[d].Dato.Next;
}

int TPrueba::GetLink(int d)
{
return M[d].Link;
}

int TPrueba::GetLibre()
{
return Libre;
}

bool TPrueba::GetSwitch(int d)
{
return (M[d].sw);
}

void TPrueba::Dibujar(TCanvas *C)
{
int xx=x,yy=y,i=0;
C->MoveTo(x,y);
C->Brush->Color=clBlack;
C->Pen->Color=clBlack;
C->Pen->Width=2;
C->Font->Color=clInfoBk;

C->Rectangle(x,y,x+60,y+20);
C->TextOutA(x+5,y+5,"DIR");
C->Rectangle(x+60,y,x+120,y+20);
C->TextOutA(x+65,y+5,"DATO");
C->Rectangle(x+120,y,x+180,y+20);
C->TextOutA(x+125,y+5,"NEXT");
C->Rectangle(x+180,y,x+240,y+20);
C->TextOutA(x+185,y+5,"LINK");
y=y+20;
while (i
{
String d=Get_Cont(i);
String s=IntToStr(Get_Next(i));
String l=IntToStr(GetLink(i));
bool sw1=GetSwitch(i);
DibujarEsp(C,x,y,IntToStr(i),sw1);
DibujarEsp(C,x+60,y,d,sw1);
DibujarEsp(C,x+120,y,s,sw1);
DibujarEsp(C,x+180,y,l,sw1);

y=y+20;
i++;
}
C->Brush->Color=clInfoBk;
C->Pen->Color=clInfoBk;
C->Rectangle(x,y+20,x+60,y+40);
C->TextOutA(x,y+20,"LIBRE: "+IntToStr(GetLibre()));

x=xx; y=yy;
}

void TPrueba::DibujarEsp(TCanvas *C, int x, int y, String Q, bool Sw)
{
if (Sw)
C->Brush->Color=clAqua;
else
C->Brush->Color=clInfoBk;
C->Pen->Color=clBlack;
C->Pen->Width=2;
C->Font->Color=clRed;
C->Rectangle(x,y,x+60,y+20);
//String S=IntToStr(Q);
C->TextOutA(x+5,y+5,Q);

}

Guardar la aplicación Prueba, en la carpeta direccionada anteriormente.

IV) Diseñar Icono de mi componente

Para hacerlo más interesante la creación de mi propio componente, éste tendrá un ícono que lo identificará, lo puedo crear a mi gusto, siguiendo los puntos siguientes:

a) Ir al Menú Tools