Club Delphi  
    FTP   CCD     Buscar   Trucos   Trabajo   Foros

Retroceder   Foros Club Delphi > Principal > OOP
Registrarse FAQ Miembros Calendario Guía de estilo Buscar Temas de Hoy Marcar Foros Como Leídos

Grupo de Teaming del ClubDelphi

Respuesta
 
Herramientas Buscar en Tema Desplegado
  #1  
Antiguo 26-03-2010
ElDuc ElDuc is offline
Miembro
 
Registrado: jul 2004
Posts: 197
Poder: 20
ElDuc Va por buen camino
Componentes en tiempo de diseño

Señores,

Sigo luchando por aprender sobre la creación de componentes, pero encuentro muchos problemas, ha ver si pudierais ayudarme.

Tengo un componente no visual y me interesaría que cuando lo inserto en un formulario me creara otro componente, visual o no, dentro de ese formulario, por ejemplo un TLabel o un TADOConnection. ESTAMOS EN TIEMPO DE DISEÑO.

Ni siquiera sé si eso es posible.

Espero que alguien pueda sacarme de este estancamiento.
Responder Con Cita
  #2  
Antiguo 26-03-2010
andres1569 andres1569 is offline
Miembro
 
Registrado: may 2003
Posts: 908
Poder: 21
andres1569 Va por buen camino
Sí que se puede hacer.

Si dicho componente "adjunto" lo creas en el mismo constructor Create, debes pasarle como Owner el mismo que recibes, para que dependa del mismo formulario. Si el componente "adjunto" es visual, es decir un Control, debes decidir dónde se ubicará, si dentro del formulario o bien dentro de un Panel por ejemplo, asignándole la propiedad Parent:

Código Delphi [-]
constructor MiComponente.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  ConexADO := TADOConnection.Create(AOwner);
  (...)
  MiLabel := TLabel.Create(AOwner);  
  if AOwner is TWinControl then MiLabel.Parent := TWinControl(AOwner);
end;

Lo más normal, al trabajar en diseño, es que el Owner sea el formulario sobre el que estés trabajando.

Saludos
__________________
Guía de Estilo
Responder Con Cita
  #3  
Antiguo 26-03-2010
ElDuc ElDuc is offline
Miembro
 
Registrado: jul 2004
Posts: 197
Poder: 20
ElDuc Va por buen camino
Gracias Andres1569

Yo ya había probado algo parecedo
Código Delphi [-]
Constructor _TgvApplication.Create(AOwner:TComponent);
Begin
Inherited Create(AOwner);
Label_1:=TLabel.Create(AOwner);
Label_1.Parent:=TWinControl(AOwner);
End;

No condiciono la asignación de Parent porque previamente ya lo había hecho poniento un breakpoint y comprobando el tipo AOwner.

También he probado de utilizar ComponentState, pero poniendo un breakpoint en tiempo de diseño no me funciona, no sé si tiene algo que ver.

Pero no me funciona, ¿qué piensas que hago mal?

Última edición por ElDuc fecha: 27-03-2010 a las 00:00:17.
Responder Con Cita
  #4  
Antiguo 27-03-2010
andres1569 andres1569 is offline
Miembro
 
Registrado: may 2003
Posts: 908
Poder: 21
andres1569 Va por buen camino
¿Qué es lo que no funciona? ¿No te aparece el Label por ningun sitio?

El objeto Owner, ¿de qué clase es? ¿es realmente un formulario? Si es un Control trata de obtener el formulario padre mediante GetParentForm(Owner) a ver qué te devuelve.

Ahora no tengo a mano el Delphi y te hablo de memoria, pero hace años implementé algo así, puede que haya que acceder al diseñador (propiedad FormDesigner -o Designer- de un TForm) pero esto desde Delphi 6 plantea problemas pues no está permitido durante RunTime utilizar clases propias del diseño (contenidas en la unit DsgnIntf.pas)

Siento no poder ayudarte más en este momento ...
__________________
Guía de Estilo
Responder Con Cita
  #5  
Antiguo 27-03-2010
ElDuc ElDuc is offline
Miembro
 
Registrado: jul 2004
Posts: 197
Poder: 20
ElDuc Va por buen camino
Angry

Estoy haciendo muchas pruebas, pero no funciona.

Es como si el método Create de mi componente sólo se ejecutara cuando ejecuto el programa (Run) pero no cuando inserto mi componente en el formularioa, que es cuando realmente necesito crear el otro componente en el formulario.

Posiblemente sea otro método o evento lo que debo controlar.
Responder Con Cita
  #6  
Antiguo 27-03-2010
ElDuc ElDuc is offline
Miembro
 
Registrado: jul 2004
Posts: 197
Poder: 20
ElDuc Va por buen camino
Es evidente que está sucediendo lo que he descrito en el post anterior.

Ge conseguido que mi componente no visual cree otro componente visual en el momento que ejecuto el programa, método Create del componente, pero no cuando inserto el componente no visual en el formulario que es cuando yo lo necesito.

Creo que debo actuar sobre otro método o evento, ¿sabéis en cual?
Responder Con Cita
  #7  
Antiguo 27-03-2010
andres1569 andres1569 is offline
Miembro
 
Registrado: may 2003
Posts: 908
Poder: 21
andres1569 Va por buen camino
Hola,

He hecho algunas pruebas y sí que se consigue crear ambos tipos de componentes, aunque he detectado algún problema con el componente NO Visual en versiones antiguas de Delphi (la 4 en concreto, en Delphi 6 no pasa). Ocurre que cuando se crea dicho componente NO visual, al no poder tener una representación en pantalla, el icono de éste no aparece, pero sí que está. Si guardo el formulario y lo vuelvo a abrir, ahí está, en la esuqina superior izquierda. Con los controles no sucede pues cuando le asignas el Parent enseguida aparece situado dentro de dicho Parent.

Deberías mirar si en la declaración de componentes del formulario te aparece dicho componente NO Visual (aunque para eso le tienes que haber asignado un nombre, cosa que el IDE hace por defecto cuando soltamos un componente desde la paleta pero que debes realizar tú en este caso). Si te aparece es que todo ha ido bien, aunque, claro, lo que tú querrías es que apereciera su icono sobre el formulario automáticamente para poderle asignar propiedades (ésto es lo que falla en la versión 4 y supongo que en anteriores, y que no he conseguido solucionar).

Te pongo un componente que he utilizado de pruebas, para que lo revises. Este código hace uso de la función GetParentForm para obtener el formulario padre a partir del AOwner (en caso de que éste sea un TControl). También te pongo una función FindUniqueName que sirve para asignarle un nombre automáticamete y que no esté repetido.

Código Delphi [-]
unit CompPrueba;

interface

uses Classes, SysUtils, Controls, Forms, StdCtrls, DB, ADODB;

type
  TComponentePrueba = class(TComponent)
  private
    MyADOConexion : TADOConnection;  // Componente No Visual
    MyLabel : TLabel;            // Componente Visual
  public
    constructor Create(AOwner: TComponent);   override;
  end;

  function FindUniqueName(AOwner: TComponent; const BaseName: string): string;

  procedure Register;

implementation

procedure register;
begin
  RegisterComponents('Pruebas', [TComponentePrueba]);
end;

// Esta función nos ayuda a dar nombre a un componente evitando que esté repetido
function FindUniqueName(AOwner: TComponent; const BaseName: string): string;
var
  i : Integer;
begin
  i := 1;
  repeat
    result := Format('%s%d', [BaseName, i]);
    Inc(i);
  until AOwner.FindComponent(result) = nil;
end;

{ TComponentePrueba }

constructor TComponentePrueba.Create(AOwner: TComponent);
var
  AForm : TCustomForm;
begin
  inherited Create(AOwner);
  // Sólo creamos los componentes "adjuntos" si AOwner no es nil y si no estamos
  // cargando el formulario de un Stream
  if Assigned(AOwner) AND NOT (csLoading in AOwner.ComponentState) then
  begin
  // CREACION DE UN Componente NO visual
    MyADOConexion := TADOConnection.Create(AOwner);
    MyADOConexion.Name := FindUniqueName(AOwner, MyADOConexion.ClassName);

  // CREACION DE UN Componente visual (TControl) ==> Hay que asignar el Parent,
  // que puede ser el formulario u otro control descendiente de TWinControl
    MyLabel := TLabel.Create(AOwner);
    MyLabel.Name := FindUniqueName(AOwner, MyLabel.ClassName);
    MyLabel.Caption := 'Label de prueba';
    AForm := nil;
    if AOwner is TControl then AForm := GetParentForm(TControl(AOwner));
    if AForm <> nil then MyLabel.Parent := AForm;
  end;
end;

end.

Saludos
__________________
Guía de Estilo
Responder Con Cita
  #8  
Antiguo 27-03-2010
ElDuc ElDuc is offline
Miembro
 
Registrado: jul 2004
Posts: 197
Poder: 20
ElDuc Va por buen camino
Thumbs up Resuelto

Hola Andes1569,

Lo he probado y funciona perfectamente sin tener que tocar nada.

Muchas gracias, la tuya ha sido una colaboración completa, me has hecho completamente los deberes.

Perdona, pero aprovechando qu entiendes un rato de esto, ¿me puedes decir algo de los editores de propiedades?

Necesito crear uno para mi componente y he buscado manuales por internet, pero lo que he encontrado


Los pasos que es necesario seguir para escribir un editor de propiedades son los siguientes:
· Crear una nueva unidad en la que definiremos el editor de propiedades. Más adelante hablaremos más extensamente sobre este punto, ya que no es tan trivial como puede parecer en principio
· Añadir la unidad DsgnIntf a la clausula uses del editor de propiedades. En esta unidad estan definidos los editores de propiedades por defecto que utiliza Delphi, además de la importantísima clase TPropertyEditor, la cuál es la clase base de todos los editores de propiedades.
· Crear una nueva clase que descienda de TPropertyEditor o de alguno de sus desciendentes. Por convención, el nombre de los editores de propiedades finaliza con la palabra Property. P.e. TIntegerProperty, TStringProperty...

A continuación se muestran los principales editores de propiedades por defecto que incorpora Delphi.
Editor de propiedades Tipo
TPropertyEditor Clase base para todos los editores de propiedades
TIntegerProperty Byte, word, integer, Longint
TCharProperty Char
TEnumProperty Tipos enumerados
TSetProperty Sets
TFloatProperty Single, Double, Extended, Comp, Currency
TStringProperty Strings
TClassProperty Cualquier objeto
TMethodProperty Cualquier método (eventos)
TComponentProperty Para propiedades que hacen referencia a componentes

· Implementar los métodos necesarios para dotar al editor de propiedades de las funcionalidades deseadas.
· Registrar el editor de propiedades en la VCL


no es compatible con delph7, el que yo utilizo, ya que delphi 7 no tiene DsgnIntf, por internet dicen que delphi 7 utiliza DesignIntf, pero éste no tiene TPropertyEditor ni los demás bases de editor por lo que estoy atascado aquí.

Última edición por ElDuc fecha: 27-03-2010 a las 21:58:10.
Responder Con Cita
  #9  
Antiguo 27-03-2010
andres1569 andres1569 is offline
Miembro
 
Registrado: may 2003
Posts: 908
Poder: 21
andres1569 Va por buen camino
Me alegro, sólo añadir que llamo a la función FindUniqueName pasándole el nombre de la clase, sería bueno quitarle la "T" que llevan por convenio las clases, y así el nombre sería igualito al que genera el IDE:

Label1 en vez de TLabel1

Saludos
__________________
Guía de Estilo
Responder Con Cita
  #10  
Antiguo 31-03-2010
andres1569 andres1569 is offline
Miembro
 
Registrado: may 2003
Posts: 908
Poder: 21
andres1569 Va por buen camino
Hola:

Te pongo aquí una explicación detallada de este asunto, espero te resulte útil. Al final te pongo un link a un curso muy recomendado para iniciarse en esto de crear componentes propios.

En efecto, tal como dice esa explicación, puedes crear tus propios editores de propiedades (descendientes de TPropertyEditor) y editores de componentes (descienden de TComponentEditor).

Los primeros se usan desde el Object Inspector, y resultan útiles cuando la propiedad en cuestión tiene cierta complejidad, o incluso si siendo simple quieres darle un tratamiento personalizado. No creo que te haga falta, por ejemplo, para introducir un Integer, o un String ... pero sí en cambio es útil tener un editor de fuentes que en realidad es una clase TFontProperty que lanza un cuadro de diálogo donde editar la fuente (TFontDialog). Lo mismo cuando quieres introducir el nombre de un archivo, aparte de poderlo introducir escribiendo, puedes crear p.e. un "TFileNameProperty" que muestre al usuario un TOpenDialog de donde elegir el archivo deseado. Básicamente hay que sobreescribir los métodos GetValue y SetValue para controlar cómo se toma el valor de la propiedad y cómo se asigna luego. Otro método que suele sobreescribirse es GetAttributes, donde puedes fijar algunas características tales como si se desplegará una lista con los posibles valores en el ObjectInspector, si dicha lista aparecerá ordenada, o si la propiedad podrá editarse simultaneamente para más de un componente. Y puesto que ya hay muchas clases que vienen "de fábrica" descendientes de TPropertyEditor, como TStringEditor, TClassEditor, TIntegerEditor ... conviene que elijas de cuál te resulta más ventajoso heredar.

Los TComponentEditor permiten crear editores para todo el componente, normalmente llaman a un formulario donde de forma más amena se pueden alterar unas cuantas, sino todas, las propiedades del componente, un ejemplo es el editor del componente TChart (el que aparece cuando haces doble click sobre el mismo), que además muestra el resultado final a medida que vas cambiando valores. Los editores de componentes se lanzan desde el menú flotante del componente, por ello es básico reescribir los métodos GetVerbCount (donde indicas cuántas entradas de menú vas a utilizar), GetVerb (donde indicas el caption de cada entrada del menú) y ExecuteVerb (que según el parámetro Index indica la entrada de menú seleccionada por el usuario para que actúes en consecuencia). Recuerda que la primera entrada del menú es la que se ejecutará por defecto cuando hagas doble click sobre el componente.

Es importante conocer algunas de la propiedades con las que contamos en estas clases. En concreto la propiedad Designer, que se refiere al diseñador del IDE. Si por ejemplo lanzas un editor de una propiedad / componente que altera algún valor, debes hacer una llamada a Designer.Modified para indicarle a Delphi que se han producido cambios (así no te llevarás la sorpresa de que no te pida guardar al salir). Puede que necesites también hacer uso del método GetComponent de ambas clases, que devuelve -según el índice que le pases como parámetro- el componente que se está editando, ya que puede ser que se estén editando varios simultaneamente.

Otra cosa IMPORTANTE, hay un antes y un después de Delphi 6 en esto de los editores de diseño:

Antes de Delphi 6, las clases TPropertyEditor y TComponentEditor venían, junto con una ristra de descendientes, en la unit DsgnIntf.pas y esta unit podías incluso incluirla en un ejecutable final, de hecho hay varias utilidades por ahí que permitían mostrar algo parecido a un ObjectInspector en runtime para cambiar propiedades durante la ejecución del programa, estas utilidades hacían uso de dicha unit que les simplificaba mucho el trabajo.

Desde Delphi 6 esto ya no está permitido, pues entonces Borland decidió que vulneraba derechos de copyright relacionados con el IDE de Delphi, y que no podían ir incluidos en ningún ejecutable final. Por ese motivo, se trasladaron todas esas clases a varias units, a saber: DesignEditors, DesignMenus y DesignWindows (puedes encontrar los fuentes en la carpeta de Delphi \Source\ToolsAPI). Esto también implica que a partir de la versión 6, si quieres crear tus propios editores de propiedades/componentes, debes crear un paquete exclusivamente de diseño, donde puedes referenciar dichas unidades, y para distribución creas otro paquete, de ejecución exclusivamente. La única diferencia entre uno y otro estará en que el de diseño llevará dichos editores, y es el que registrarás en el IDE de Delphi para que te aparezcan en la paleta. Ten en cuenta, también, que estas tres units no están accesibles como archivos .DCU, sino que residen en un package llamado designide.dcp. Esto implica que para poder usarlas en el package de diseño debes incluir el package designide.dcp en su cláusula Requires.

A todo esto, a partir de Delphi 6 la unit DsgnIntf.pas cambia de nombre a DesignIntf.pas, y alberga únicamente interfaces y algunos tipos útiles, y reside también en el package designide.dcp (no hay un archivo .dcu tampoco para esta unit). A propósito, los fallos que mucha gente tenía con una unit llamada "proxies" también tenían que ver con esta remodelación.

Te pongo aquí un ejemplo de editor de propiedades y otro de editor de componentes. Como sabrás, no basta con definir dichas clases sino que, obviamente, hay que asignarlas al componente y/o propiedad deseada, para que Delphi sepa dónde aplicarlos. Para ello se usan los procedimientos RegisterPropertyEditor y RegisterComponentEditor (en ambos en el parámetro ComponentClass se debe indicar a qué clase -y derivados- afectará).

Código Delphi [-]
type

  TAliasProperty = class(TStringProperty)
  public
    function GetAttributes : TPropertyAttributes;  override;
    procedure GetValues(Proc: TGetStrProc);   override;
  end;

  TMiComponenteEditor = class(TComponentEditor)
  public
    procedure ExecuteVerb(Index: Integer);   override;
    function GetVerb(Index: Integer) : String;   override;
    function GetVerbCount : Integer;   override;
  end;

  procedure Register;

implementation

procedure Register;
begin
// registramos el componente
  RegisterComponents('MiPaleta', [TMiComponente]);
// registramos el editor de la propiedad 'Alias' para TMiComponente
  RegisterPropertyEditor(TypeInfo(String), TMiComponente, 'Alias', TAliasProperty);
// registramos el editor de TMiComponente
  RegisterComponentEditor(TMiComponente, TMiComponenteEditor);
end;

{ TAliasProperty }

function TAliasProperty.GetAttributes: TPropertyAttributes;
begin
  result := [paValueList, paMultiSelect, paSortList];
end;

// TGetStrProc es un tipo de función que recibe un valor cadena para añadir 
// a una lista que mostrará al usuario desde el ObjectInspector
procedure TAliasProperty.GetValues(Proc: TGetStrProc);
var
  AliasList : TStringList;
  i : Integer;
begin
  AliasList := TStringList.Create;
  Session.ConfigMode := cmAll;   // que busque todos los alias posibles
  Session.GetAliasNames(AliasList);
  try
    for i:=0 to AliasList.Count - 1 do Proc(AliasList[i]);
  finally
    AliasList.Free;
  end;
end;  

{ TMiComponenteEditor }

// según el parámetro Index, lanzamos la acción / formulario correspondiente
procedure TMiComponenteEditor.ExecuteVerb(Index: Integer);
begin
  Case Index of
    0 : with TMiComponenteForm.Create(nil) do
          try
            if ShowModal = mrOk then Designer.Modified;
          finally
            Free;
          end; 
    1 : with TMiComponentePreviewForm.Create(nil) do
          try
            ShowModal;
          finally
            Free;
          end; 
  end;
end;

// según el parámetro Index, indicamos el Caption de cada entrada del menú
function TMiComponenteEditor.GetVerb(Index: Integer): String;
begin
  Case Index of
    0 : result := 'Editar valores ...';
    1 : result := 'Previsualizar';
  end;
end;

// devuelve el número de entradas que vamos a añadir al menú 
function TMiComponenteEditor.GetVerbCount: Integer;
begin
  result := 2;
end;

Por último, un consejo: los componentes debes crearlos en unidades aparte de la de los editores. Para los editores creas una unidad dedicada exclusivamente, llamémosla MisComponentesReg.pas, ahí es donde añades en la cláusula Uses las units DesignIntf, DesignEditors -DesignMenus y DesignWindows pueden ser optativas- o bien DsgnIntf si trabajas en versiones anteriores a la 6. En dicha unit además es donde registrarás los componentes por lo que deberá llevar enlazadas todas las units donde los tengas implementados. En realidad, al package de diseño sólo le tienes que añadir esta unidad para que Delphi te los instale en la paleta.

Otra aclaración: puesto que a partir de Delphi no se permiten crear aplicaciones que usen las unidades propias del diseño, a la hora de depurar la unit MisComponentesReg.pas, esto no lo podrás hacer incluyéndola en un proyecto tal cual y compilando, ya que te saltará el error del tipo: "File not found DesignIntf.dcu'. Debes crear el package de diseño, incluirle dicha unit, y compilar el package cada vez que quieras depurarla.

Te pongo un enlace a un "Curso de creación de componentes" que me fue muy útil en su día, confeccionado por Luis Roche:

http://www.publispain.com/supertutor...os/4/ccind.htm

Saludos
__________________
Guía de Estilo
Responder Con Cita
  #11  
Antiguo 02-04-2010
ElDuc ElDuc is offline
Miembro
 
Registrado: jul 2004
Posts: 197
Poder: 20
ElDuc Va por buen camino
Angry Imposible Para Mi

Hola andres 1569,

En primer lugar quiero agradecerte de verdad el esfuerzo que estás haciendo por ayudarme a entender el tema de los componentes en Delphi, no me imaginaba que alguien pudiera hacer tanto por un novato como yo, GRACIAS.

No te he contestado hasta ahora porque antes quería trabajar sobre tu último post y tenía la esperanza de poderte decir que todo estaba solucionado.

Creo que el problema lo tengo con los 2 paquetes que me indicas debo trabajar. Yo programo con Delphi 7.

He leido tu explicación muchas veces y lo he intentado otras tantas, pero el resultado siempre es el mismo, cuando consigo que funcione mi editor de propiedades en tiempo de diseño, no puedo ejecutar porque me da el maldito problema de "Proxies".

Incluso, siguiendo un consejo que encontré en este foro, he creado mi unidad Proxies.pas y devuelvo true en la función que se utiliza, entonces se ejecuta pero no funciona mi editor de propiedades.

Yo pienso que la solución está en tu explicación, pero no soy capaz de comprender el tema de los 2 paquetes y qué debo poner en cada uno.

Aún a riesgo de que pienses que me estoy pasando y para que el esfuerzo que hemos hecho hasta ahora no sea en vano, te ruego me pases un esqueleto de lo que debo hacer, algo así:

Paquete de diseño PDMyComponent:
Contens
Unidad 1.pas -> ¿pas o dcu?
Unidad 2.pas -> ¿pas o dcu?
Requires
Paquete 1
PRMyComponent -> Yo sólo lo pongo como ejemplo
...

Paquete de distribución/¿ejecución? PRMyComponent:
Contens
Unidad 3.pas -> ¿pas o dcu?
Unidad 4.pas -> ¿pas o dcu?
Requires
Paquete 1
...

Lo que pongo en cada unidad:
Unidad 1.Pas
Uses
...
Definición y registro del editor de propiedades.

Unidad 2.Pas
Uses
...
Definición y registro del componente.

Unidad 1.Pas
Uses
...
Definición ...

Unidad 1.Pas
Uses
...
Definición ...

¿Qué hago con el paquete PDMyComponent?, ¿lo instalo en el IDE?, y con el otro ¿què hago?

Como puedes ver no he entendido nada, si puedes, ¡hèchame una mano!
Responder Con Cita
  #12  
Antiguo 12-04-2010
andres1569 andres1569 is offline
Miembro
 
Registrado: may 2003
Posts: 908
Poder: 21
andres1569 Va por buen camino
Hola de nuevo, ElDuc:

Lo que voy a comentarte ya está en mi post anterior. Veamos, los componentes los defines e implementas en unidades aparte de la que vas utilizar para registrarlos, y que llamaremos en adelante MisComposReg.pas, por ejemplo. Da igual si utilizas una sola unit para implementar unos cuantos componentes (esto sucede muchas veces en la VCL), o como recomienda Marco Cantú dedicas una unit exclusivamente para cada componente. Pero lo que importa es que en estas unidades no hagas ninguna mención a las unidades de diseño: DesignIntf, DesignEditors, DesignMenus y DesignWindows. Si lo haces te saltará ese maldito error con la unit "proxies".

Ten en cuenta que dichas unidades, aparte de ser las que utilizará el IDE de Delphi para "conocer" tus componentes, son las que se enlazarán a cualquier ejecutable que los utilice, por lo que no pueden aludir a nada que tenga que ver con el diseño (por el asunto del Copyright que te comenté en mi anteriro post).

La clave está en crear una unit dedicada exclusivamente a implementar los editores de propiedades/componentes (MisComposReg.pas), ahí SI metes en la cláusula Uses las unidades referidas de diseño: DesignIntf, DesignEditors, DesignMenus y DesignWindows (no todas son necesarias, usa las que te hagan falta). Aparte, como es lógico, debes incluir en esta unidad referencias a las unidades donde has implementado los componentes. El procedimiento Register, donde registras los componentes y los editores, DEBE IR SÓLO EN ESTA UNIDAD.

Vayamos con los paquetes:

Esencialmente sólo necesitas crear uno, el de diseño (el de ejecución sólo te hará falta si quieres que los programas que utilicen tus componentes lo hagan mediante la opción Runtimes packages, ahí si necesitas crear un paquete de ejecución para distribuir con tu aplicación).

En cuanto al paquete de diseño, sólo tienes que añadirle en la cláusula REQUIRES la referencia al paquete designide.dcp que viene con Delphi, y basta con que le añadas solamente la unidad MisComposReg.pas donde se registran los componentes y los editores. Ninguna unidad más. Éste es el paquete que instalas en Delphi. El archivo que debes añadir es el .pas, ya que Delphi debe compilarlo desde ese paquete precisamente (nada de .dcu).

Y referente a lo de crear una unit "proxies.pas" para engañar al sistema, olvídate, simplemente quita las famosas units DesignXXX de todas las unidades menos de MisComposReg.pas, y no te saltará ese error.

Saludos,

Andrés
__________________
Guía de Estilo
Responder Con Cita
  #13  
Antiguo 10-02-2011
Avatar de burgosrodas
burgosrodas burgosrodas is offline
Miembro
 
Registrado: sep 2008
Ubicación: Colombia
Posts: 24
Poder: 0
burgosrodas Va por buen camino
Error al Crear componente Visual

Buen dia
he leido el hilo completamente y es muy interesante pero me he encontrado con un problema que quisiera alguien me pudiera colaborar.
quiero crear mi componente de la siguiente manera:

quiero crear un DBGrid que al soltarlo en mi form (o en un panel)
el automaticamente cambie su parent a un panel que se crea dinamicamente
y dicho panel dinamico se ubica donde se pretendia tener el DBGrid, esto con el fin de agregar un statusbar, y un buscador automatico para dicho DBgrid alineados alBottom, entonces se crea el efecto de tener un buscador en cada DBGrid que adiciono a mi proyecto.
esto no tiene problema, pues en tiempo de diseño, todo pinta bien, el problema aparece cuando intento ejecutar mi componente, pues sale el error
"raised exception class EClassNotFound with message 'Class TPanel not found."




Código Delphi [-]
constructor TKDBGrid.Create(AOwner : TComponent);
begin
     inherited Create(AOwner);
                                                
        Panel:=TPanel.Create(AOwner);
        Panel.Parent:=TWinControl(AOwner);

        Self.Parent:=Panel;  // self es el DBGrid en mi caso JvDBUltimGrid
        Self.Align:=alClient;  // el DBGrid ocupa todo el panel creado

        CrearBuscador;
end;


no en tiendo como hacer, por ultimas intente hacerlo al revez
hago que mi componente sea un panel, y cualdo se crea instancia un DBGrid dentro de el, pero ahroa el problema es que no encuentra la clase TDBGrid >=(
alguien que me guie por favor
espero haberme hecho entender
gracias
Responder Con Cita
Respuesta


Herramientas Buscar en Tema
Buscar en Tema:

Búsqueda Avanzada
Desplegado

Normas de Publicación
no Puedes crear nuevos temas
no Puedes responder a temas
no Puedes adjuntar archivos
no Puedes editar tus mensajes

El código vB está habilitado
Las caritas están habilitado
Código [IMG] está habilitado
Código HTML está deshabilitado
Saltar a Foro

Temas Similares
Tema Autor Foro Respuestas Último mensaje
No veo, en tiempo de diseño los nombres de los componentes QuarkBcn Varios 3 19-12-2007 10:38:31
eventos en tiempo de diseño jar OOP 0 27-01-2007 23:09:11
Indices En Tiempo De Diseño?? amadis Conexión con bases de datos 0 12-04-2006 21:22:01
Diseño en tiempo de ejecucion Nelson Alberto Impresión 2 26-01-2006 10:34:12
Instalar componentes solo en tiempo de diseño DarKraZY Varios 0 19-08-2003 17:47:37


La franja horaria es GMT +2. Ahora son las 10:45:15.


Powered by vBulletin® Version 3.6.8
Copyright ©2000 - 2024, Jelsoft Enterprises Ltd.
Traducción al castellano por el equipo de moderadores del Club Delphi
Copyright 1996-2007 Club Delphi