---

PROPIEDADES AGREGANDO

Primero usted agregará propiedades al objeto de COM. Aquí está los pasos:

1. Pulse el botón en el nodo de IMultiply en la hoja de vidrio del Objeto del Editor de Biblioteca de Tipo. Aviso que la hoja de vidrio de Información muestra el nombre de la interface, GUID, y versión. También note que el campo de Interface de Padre muestra al antepasado de IMultiply como IUnknown. Si usted revoca, yo dije antes ese IUnknown es la base (o padre) interface de la que todas las otras interfaces se derivan. Delphi asume una interface baja de IUnknown automáticamente. Usted puede cambiar la interface baja a alguna otra interface si usted quiere escoger una interface de la lista de interfaces disponibles. Otras interfaces en la lista se son derivado de IUnknown o uno de sus descendientes.

2. Derecho-pulse el botón y escoge New|Property del menú del contexto. El Editor de Biblioteca de Tipo agrega dos nuevos nodos a la hoja de vidrio de los Objetos bajo la interface de IMulitply. El cursor está revisando modo para que usted pueda teclear el nombre de la nueva propiedad.

3. Teclee X para el nombre de propiedad y entonces apriete el Entre en llave. Los dos del nuevo cambio de los nodos a X. There son dos nodos a cada propiedad porque, por defecto, se asume que una propiedad es una propiedad del read/write. COM requiere un Haga al método leer una propiedad y un método Puesto para escribir a una propiedad, de las dos entradas. Pulse el botón en cualquiera de los dos nodos etiquetó X. Notice el Invoca campo Amable en la hoja de vidrio de Información cuando usted selecciona primero uno el nodo de X y entonces el otro. Aviso que el campo cambia de la Propiedad Puesto a la Propiedad Consigue.

4. Aviso en la hoja de vidrio de Información que el campo del Tipo dice Entero. Eso es los datos teclean usted quiere para esta propiedad, para que usted no necesita cambiar el tipo.

5. Cree otra nueva propiedad pero este tiempo usa un acercamiento diferente. Localice el Nuevo botón de Propiedad en el Tipo Biblioteca Editor toolbar. Pulse el botón el gota-baje flecha al lado del Nuevo botón de Propiedad. Escoja Read|Write de la lista de tipos de propiedad. El Editor de Biblioteca de Tipo crea la nueva propiedad. Nombre esta propiedad Y. que Usted puede aceptar que los datos predefinidos también teclean de Entero para esta propiedad. Detrás de las escenas Delphi está agregando código a las unidades del proyecto cuando usted agrega elementos.

---

Agregando un Método

Luego, usted agrega un método. Realice estos pasos:

1. Seleccione que los IMultiply objetan en la hoja de vidrio del Objeto y pulsan el botón el Nuevo botón del Método en el Tipo Biblioteca Editor toolbar.

2. Nombre el método DoIt. Aviso que el Invoque el campo Amable dice Función (como opuso a la Propiedad Consigue y la Propiedad Puso).

Luego usted debe poner los parámetros del método. El método tendrá esta sintaxis:

función DoIt: Entero;

3. Pulse el botón en la etiqueta de los Parámetros en la hoja de vidrio de Información. Cambie el campo de Tipo de Retorno al Entero (escoge Entero de la caja del combo). Este método no tiene ningún parámetro, para que usted puede salir que los Parámetros listan vacío. Después de que usted ha puesto el tipo del retorno, pulse el botón la etiqueta de los Atributos para desplegar la página de los Atributos. Este paso no es estrictamente necesario, pero sirve lo atrás al propósito de toma a donde usted empezó.

4. Pulse el botón el Refresqúese botón de Aplicación en el Tipo Biblioteca Editor toolbar.

Ahora que usted ha agregado las dos propiedades y métodos, es tiempo para ver lo que Delphi ha estado haciendo detrás de las escenas. 15.1 muestras listando la unidad de la clase cuando aparece después de realizar los pasos a a este punto. (No preocupa si su unidad no se parece Listando 15.1 exactamente. Mi versión de Delphi podría haber agregado código en un orden ligeramente diferente que suyo.)

LISTANDO 15.1. MultiplyU DESPUÉS DE AGREGAR PROPIEDADES Y UN MÉTODO.

unidad MultiplyU;  

interface  

usos  

  Windows, ActiveX, ComObj, ComTest_TLB,;  

tipo  

  TMultiply = el class(TTypedComObject, IMultiply)  



  protegido  

    función DoIt: Entero; el stdcall;  

    función Get_X: Entero; el stdcall;  

    función Get_Y: Entero; el stdcall;  



    procedimiento Set_X(Value: Entero); el stdcall;  

    procedimiento Set_Y(Value: Entero); el stdcall;  

    {Declare métodos de IMultiply aquí}  



  extremo;  

aplicación  

usos ComServ;  

función TMultiply.DoIt: Entero;  

empiece  

extremo;  

función TMultiply.Get_X: Entero;  

empiece  



extremo;  

función TMultiply.Get_Y: Entero;  

empiece  

extremo;  

procedimiento TMultiply.Set_X(Value: Entero);  

empiece  

extremo;  



procedimiento TMultiply.Set_Y(Value: Entero);  

empiece  

extremo;  

inicialización  

  TTypedComObjectFactory.Create(ComServer, TMultiply, Class_Multiply,  



    ciMultiInstance, tmSingle);  

extremo.   

Ésta es la cáscara del objeto de COM. Aviso que la clase de TMultiply se deriva de TTypedComObject y " IMultiply. (A programadores de C++, esto podría parecerse herencia múltiple. No es ninguna herencia precisamente múltiple, pero es similar de algunas maneras.) Usted no ha visto al IMultiply clasificar todavía, pero usted lega un pedazo después. Usted debe rellenar esta cáscara para hacer los COM objete haga algo. Usted hará ese próximo.

Código agregando

Usted agregará código ahora a la clase de TMultiply hacer a los COM objetar funcional. Realice estos pasos (refiérase a Listar 15.2 si necesario):

1. Despliegue la unidad de MuliplyU.pas en el Editor del Código. Agregue estas líneas al TMultiply clasifique declaración, sólo sobre el keyword protegido:

privado  

  FX: Entero;  

  FY: Entero;

Éstas son las declaraciones para los campos de los datos que celebrarán los X y Y propiedad valores.

2. Desfile abajo en la sección de aplicación y localice el método de Get_X (usa al Explorador del Código si le gusta). Teclee esta línea de código en el método:

Resultado := FX;

3. Localice el método de Get_Y y agregue esta línea:

Resultado := FY;

4. Localice el método de DoIt y agregue esta línea de código:

Resultado := FX * FY;

Esta línea de código multiplica el valor de FX y FY y ingresos el resultado.

5. Desfile más allá abajo hasta que usted vea el método de Set_X. Teclee esta línea de código en el método de Set_X:

FX := el Valor;

6. Localice el método de Set_Y y agregue esta línea:

FY := el Valor;

Ése es todos que usted necesita hacer. Su código debe parecerse Listando 15.2 ahora.

LISTANDO 15.2. LA UNIDAD de MultiplyU COMPLETADA.

unidad MultiplyU;  

interface  

usos  

  Windows, ActiveX, ComObj, ComTest_TLB,;  



tipo  

  TMultiply = el class(TTypedComObject, IMultiply)  

  privado  

    FX: Entero;  

    FY: Entero;  

  protegido  

    función DoIt: Entero; el stdcall;  



    función Get_X: Entero; el stdcall;  

    función Get_Y: Entero; el stdcall;  

    procedimiento Set_X(Value: Entero); el stdcall;  



    procedimiento Set_Y(Value: Entero); el stdcall;  

    {Declare métodos de IMultiply aquí}  

  extremo;  

aplicación  

usos ComServ;  



función TMultiply.DoIt: Entero;  

empiece  

  Resultado := FX * FY;  

extremo;   

función TMultiply.Get_X: Entero;  

empiece  

  Resultado := FX;  



extremo;  

función TMultiply.Get_Y: Entero;  

empiece  

  Resultado := FY;  

extremo;  

procedimiento TMultiply.Set_X(Value: Entero);  



empiece  

  FX := el Valor;  

extremo;  

procedimiento TMultiply.Set_Y(Value: Entero);  

empiece  

  FY := el Valor;  



extremo;  

inicialización  

  TTypedComObjectFactory.Create(ComServer, TMultiply, Class_Multiply,  

    ciMultiInstance, tmSingle);  



extremo.  

Aunque usted estaba trabajando en la unidad de MulitplyU, Delphi era edificio ocupado la biblioteca del tipo y una unidad para contener el código de biblioteca de tipo. La unidad tiene el mismo nombre como el proyecto con un _TLB arrastrando. Este proyecto se nombra ComTest. El nombre de la unidad lleno para la unidad de biblioteca de tipo, entonces, es ComTest_TLB.pas. 15.3 muestras listando esta unidad cuando existe a estas alturas. Recuerde, su unidad no podría parecerse Listando 15.3 exactamente.

LISTANDO 15.3. LA UNIDAD de ComTest_TLB.pas.

unidad ComTest_TLB;  

/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /  



/ / ADVIRTIENDO / /  

/ /------- / /  

/ / Se generaron los tipos declarados en este archivo de datos leídos de un / /  

/ / La Biblioteca del tipo. Si esta biblioteca del tipo es explícitamente o indirectamente (vía / /  



/ / otra biblioteca del tipo que se refiere a esta biblioteca del tipo) el reimported, o / /  

/ / el `Refresh ' el orden del Editor de Biblioteca de Tipo activó mientras / /  



/ / revisando la Biblioteca del Tipo, los volúmenes de este archivo serán / /  

/ / regeneró y todas las modificaciones manuales se perderán.               / /  



/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /  



/ / PASTLWTR: $Revision:   1.11.1.55 $  

/ / El archivo generó en 6/8/98 7:16:51 PM de Biblioteca del Tipo descrita debajo.  

/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /  



/ / El tipo Lib: D:\Borland\D4\Bin\ComTest.tlb  

/ / IID\LCID: {7CDAFB76-FF36-11D1-81F1-0040052A83C4}\0  

/ / Helpfile:   

/ / HelpString: Biblioteca de ComTest  



/ / La versión:    1.0  

/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /  



interface  

usos Windows, ActiveX, Clases, Gráficos, OleCtrls, StdVCL,;   

/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /  



/ / GUIDS declaró en el TypeLibrary. Se usan prefijos siguientes:      / /  

/ / Las Bibliotecas del tipo: LIBID_xxxx / /  

/ / CoClasses: CLASS_xxxx / /  



/ / DISPInterfaces: DIID_xxxx / /  

/ / No-DISP las interfaces: IID_xxxx / /  

/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /  



const  

  LIBID_ComTest: TGUID = ` {7CDAFB76-FF36-11D1-81F1-0040052A83C4} ';  

  IID_IMultiply: TGUID = ` {7CDAFB77-FF36-11D1-81F1-0040052A83C4} ';  



  CLASS_Multiply: TGUID = ` {7CDAFB79-FF36-11D1-81F1-0040052A83C4} ';  

tipo  

/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /  



/ / La declaración delantera de interfaces definió en Biblioteca del Tipo / /  

/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /  



  IMultiply = la interface;  

/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /  



/ / La declaración de CoClasses definió en Biblioteca del Tipo / /  

/ / (NOTA: Aquí nosotros trazamos cada CoClass a su Interface Predefinida) / /  



/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /  



  Multiplique = IMultiply;  

/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /  



/ / La interface: IMultiply  

/ / Las banderas:     (0)  

/ / GUID:      {7CDAFB77-FF36-11D1-81F1-0040052A83C4}  

/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /  



  IMultiply = el interface(IUnknown)  

    [` {7CDAFB77-FF36-11D1-81F1-0040052A83C4} ']  

    función Get_X: Entero; el stdcall;  

    procedimiento Set_X(Value: Entero); el stdcall;  



    función Get_Y: Entero; el stdcall;  

    procedimiento Set_Y(Value: Entero); el stdcall;  

    función DoIt: Entero; el stdcall;  



  extremo;  

  CoMultiply = la clase  

    la función de la clase Crea: IMultiply;  

    función de la clase CreateRemote(const MachineName: cordón): IMultiply;  



  extremo;  

aplicación  

usos ComObj;  

función de la clase CoMultiply.Create: IMultiply;  

empiece  

  Resultado := CreateComObject(CLASS_Multiply) como IMultiply;  



extremo;  

función de la clase CoMultiply.CreateRemote(const MachineName: cordón): ÂIMultiply;  

empiece  

  Resultado := CreateRemoteComObject(MachineName, CLASS_Multiply) como ÂIMultiply;  



extremo;  

extremo.  

Note que esta unidad contiene la declaración para la interface de IMultiply. Cuando usted puede ver, IMultiply se deriva de IUnknown. También note que que esta unidad contiene que los coclass Multiplican.

Es importante entender que que esta unidad se regenera cada tiempo que usted compile un ActiveX biblioteca proyecto. Se genera del archivo de biblioteca de tipo. Note la advertencia a la cima de la unidad. Los comentarios están diciéndole que se perderá cualquier cambio que usted hace a este archivo la próxima vez que el objeto de COM se reconstruye. Realmente no hace cualquier bueno para modificar el tipo biblioteca fuente archivo, porque se regenerará automáticamente.

Construyendo y Registrando el Objeto de COM

Ahora usted está listo compilar el ActiveX biblioteca proyecto. Este paso compila los COM objetan y figuras el DLL en el que el objeto de COM reside. Después de construir el COM objete, usted puede registrarlo. Aquí está los pasos:

1. Escoja Project|Build ComTest del menú principal. Delphi construirá el DLL que contiene el objeto de COM.

2. Escoja Run|Register ActiveX Servidor del menú principal. Este paso registra que los COM objetan con Windows. Si usted no realiza este paso, usted conseguirá una excepción que dice, "la Clase no registró" cuando usted intenta acceder el objeto de COM.

Delphi registra que los COM objetan DLL con Windows. Después de que el DLL ha sido registrado, Delphi despliega una caja del mensaje, como mostrado en Figura 15.4.

FIGURE 15.4. Delphi que informan el COM objetan substancialmente registrado.

Cuando Windows registra que los COM objetan, agrega información sobre el objeto al Registro. Figure 15.5 muestras la entrada del Registro creada cuando el objeto de COM era registrado con Windows.

FIGURE 15.5. La llave del Registro creó cuando el objeto de COM era registrado.

---

NOTA: Delphi envía con una utilidad llamado TREGSVR.EXE que puede ser acostumbrado a registrar un mando de ActiveX de la línea del orden. Registrar un mando llamado MYSTUFF.OCX, usted ejecutaría TREGSVR de una sugerencia del orden gusta esto:

tregsvr mystuff.ocx

Al unregister un ActiveX, use los -u cambian como sigue:

tregsvr -u mystuff.ocx

A veces esto es más conveniente que cargando un proyecto de ActiveX en Delphi y registrando o unregistering el mando del IDE.

---

---

NOTA: En este ejercicio yo lo hice crea un objeto de COM. Usted también podría usar un objeto de automatización. Un objeto de automatización deriva de IDispatch en lugar de IUnknown. IDispatch proporciona la funcionalidad adicional requerida para un objeto de COM para actuar como un servidor de automatización (un objeto que puede controlar una aplicación de otro).

---

Su objeto de COM está ahora listo para usar.

Construyendo una Aplicación Que Usa el Objeto de COM

Un objeto de COM no lo hace muy bueno si usted no puede usarlo. En este paso, usted crea una aplicación que usa el COM simplemente objete usted creó. Siga estos pasos:

1. Cree una nueva aplicación. Ponga un componente del Botón y un componente de la Etiqueta en la forma. Ahorre el proyecto como ComApp y la unidad de la forma principal como ComAppU.

2. Cambie al Editor del Código y localice los usos listan para la unidad principal. Agregue estas unidades a la lista de los usos:

ComObj  

ComTest_TLB

Esto asegura que el código que referencias que el objeto de COM compilará.

3. Doble-pulse el botón el botón de la forma para crear a un OnClick evento negociante. Modifique al negociante de OnClick para que se parezca:

procedimiento TForm1.Button1Click(Sender: TObject);  



var  

  Mult: IMultiply;  

  Res: Entero;  

empiece  

  Mult := CreateComObject(CLASS_Multiply) como IMultiply;  

  si Assigned(Mult) entonces empieza  



    Mult.Set_X (20);  

    Mult.Set_Y (60);  

    Res := Mult.DoIt;  

    Label1.Caption := IntToStr(Res);  

  extremo;  

extremo;

Este código declara un indicador primero a la interface de IMultiply llamó Mult y un Entero inconstante sostener el resultado. Luego, la función de CreateComObject se llama con un parámetro de CLASS_Multiply. CLASS_Multiply es una constante que contiene el GUID para el COM objete clase (refiérase a Listar 15.3).

El valor del retorno de CreateComObject se asigna al indicador de Mult. Aviso que yo uso el cuando operador lance el valor del retorno a un indicador de IMultiply. CreateComObject devuelve un indicador de IUnknown, para que el cuando operador es acostumbrado a lanzar el indicador de IUnknown a un indicador de IMultiply.

Después de que el objeto de COM se crea, yo asigno valores a los X y a propiedades de Y. Después de eso yo llamo el método de DoIt del objeto de COM y despliego el resultado en el componente de la Etiqueta.

---

NOTA: En el mundo real, yo habría escrito el procedimiento precediendo diferentemente. Por ejemplo:

procedimiento TForm1.Button1Click(Sender: TObject);  

empiece  

  con CreateComObject(CLASS_Multiply) como IMultiply empieza  



    Set_X(20);  

    Set_Y(60);  

    Label1.Caption := IntToStr(DoIt);  

  extremo;  

extremo;

Yo escribí la manera al procedimiento que yo hice para ilustrar cada paso.

---

Ejecute el programa. Cuando usted pulsa el botón el botón de la forma, la etiqueta debe cambiar para decir "1200" (el producto de 20 * 60). ¡Ése es él! Sus COM objetan trabajos. Este objeto de COM puede usarse de C++ Básico, Visual Visual, C++Builder, o cualquier otro ambiente de desarrollo que apoyan COM.

ActiveX comprensivo

ActiveX es un relativamente nuevo término para una tecnología para la que ha sido por un rato alrededor. Originalmente se llamaron mandos de ActiveX los mandos de OCX. El término que OCX todavía se usa ampliamente en algunos círculos. Un mando de ActiveX tiene una extensión del filename de DLL o OCX típicamente.

Un mando de ActiveX es esencialmente un objeto de COM en fingimiento. La diferencia primaria entre un mando de ActiveX y un objeto de COM es que un mando de ActiveX tiene una interface del plan-tiempo. Un mando de ActiveX también tiene código que le permite que sea desplegado en una página de Tejido o encima de una red. ActiveX es un subconjunto de COM, para que todo lo que usted aprendió sobre los objetos de COM en la primera parte del capítulo también aplica a los mandos de ActiveX.

Mandos de ActiveX Terceristas usando

No hay mucho saber sobre instalar y usar mandos de ActiveX terceristas. Todos que usted tiene que hacer son importación el ActiveX en el IDE y empiezan usando el mando. Para ver cómo esto trabaja, hagamos un ejercicio rápido. Este ejercicio requiere que usted tiene Microsoft Internet Explorador instalado en su sistema. Si usted no tiene Explorador de Internet instalado, salte este ejercicio. (Usted no estará extrañando nada porque yo le muestro cómo instalar un mando de ActiveX que usted ha construido en la sección "la Figura, Registre, y Instale el Mando".) Realice estos pasos:

1. Escoja Component|Import ActiveX Mando del menú principal. La Importación que ActiveX dialogan que la caja se despliega.

2. Desfile abajo a través de la lista de componentes instalados hasta que usted encuentre Microsoft Internet Mandos (el texto exacto del artículo dependerá de la versión de Explorador de Internet usted ha instalado en su sistema). Seleccione el artículo. Figure 15.6 muestras la Importación que ActiveX dialogan caja después de este paso.

FIGURE 15.6.La Importación ActiveX dialogan caja.

Note que la Clase nombra caja de la lista en el medio de la página. Esta caja de la lista contiene una lista de mandos de ActiveX en el archivo seleccionado (SHDOCVW.DLL en este caso).

3. El campo de página de Paleta muestra ActiveX. Esto es un la página de la paleta donde los nuevos mandos se instalarán. Pulse el botón en este campo y tipo ActiveXTest.

4. Salga los dir de la Unidad nombran y campos de camino de Búsqueda en sus escenas predefinidas y pulsa el botón el Instale botón. El Instale la caja del diálogo surge y pregunta qué paquete en el que los mandos instalaron usted quiere. (Todos los mandos, si ellos son VCL o ActiveX, debe estar en un paquete.)

5. Pulse el botón adelante el En la nueva etiqueta del paquete. Entre en MSIE en el campo de nombre de Archivo y Internet Explorador Paquete en el campo de la Descripción.

6. Pulse el botón el botón de OK. Delphi crea que un nuevo paquete llamó MSIE.dpk y sugerencias usted construir y instalar el paquete. Pulse el botón Sí para instalar el paquete. Después de que el paquete se construye, Delphi despliega una caja del mensaje que le dice qué mandos se agregaron a la paleta del Componente. Pulse el botón Sí para despedir la caja del mensaje.

7. Desfile la paleta del Componente para encontrar la etiqueta de ActiveXText. Usted debe ver dos o tres mandos en esa página de la paleta del Componente (de nuevo, dependiendo de la versión de Explorador de Internet usted han instalado). Los componentes están listos para el uso.

Experimente con los nuevos mandos y ve cómo ellos trabajan. Usted no se pondrá muy lejano probablemente sin la documentación, pero por lo menos usted consigue un sentido para cómo instalando un trabajos de ActiveX. (Para una explicación más completa de usar al Explorador de Internet como un ActiveX, vea la sección, "Usando al Explorador de Internet como un Mando de ActiveX" en el Día de la Paga extraordinaria, "Construyendo Aplicaciones de Internet".)

---

NOTA: Usted debe tener una licencia del plan-tiempo para usar un mando de ActiveX instalado. Una licencia del plan-tiempo es un archivo con una extensión de .LIC. En algunos casos usted puede importar mandos de ActiveX a la Delphi Componente paleta sin una licencia del plan-tiempo, pero usted conseguirá un mensaje del error cuando usted intenta poner el mando en su forma.

---

Quitar al Explorador de Internet controla de la paleta del Componente, escoja Paquetes de Component|Install del menú principal. Localice el Internet Explorador Paquete en el Plan empaqueta caja de la lista y pulsa el botón el Quite botón. La etiqueta de ActiveXTest está alejada de la paleta del Componente.

---

NOTA: Desplegando una aplicación que usa mandos de ActiveX requiere atención especial. Se cubren aplicaciones desplegando que usan mandos de ActiveX en detalle en el Día de la Paga extraordinaria en la sección "Desplegando Aplicaciones de Internet."

---

Nuevos Mandos de ActiveX creando

Hay dos maneras de crear un mando de ActiveX en Delphi:

• De un componente de VCL existiendo

• Usando un ActiveForm desde el principio

En esta sección, usted crea un mando de ActiveX que usa los dos de estos métodos.

Creando un Mando de ActiveX de un Componente de VCL Existiendo

Creando un mando de ActiveX de un componente de VCL existiendo es francamente simple. Después de que usted crea un componente, usted puede convertirlo en absoluto en un mando de ActiveX por ningún tiempo. Yo no he hablado sobre crear componentes todavía, para que yo no quiero entrar en mucho detalle en crear componentes ahora (cubrió en Día 20, "Creando Componentes"). Lo que usted hará, entonces, es cree un mando de ActiveX de uno de los componentes de VCL proporcionado por Borland.

Genere el ActiveX Project con el ActiveX Mando Mago

El primer paso es generar el proyecto de ActiveX. Como siempre, Delphi hace la mayoría del trabajo para usted. Todos que usted tiene que hacer son suministro unos campos en el ActiveX Mando Mago. Aquí está los pasos:

1. Escoja File|Close Todos para cerrar todos los proyectos y entonces escoger File|New del menú principal. El Almacén del Objeto se despliega.

2. Pulse el botón que los ActiveX compaginan y entonces doble-pulsan el botón el ActiveX Control el icono. El ActiveX Mando Mago se despliega (vea Figura 15.7).

FIGURE 15.7.El ActiveX Mando Mago.

3. TButton selecto de la lista de clases en la VCL Clase Nombre combo caja. Los próximos cuatro campos están automáticamente llenos en con valores de valor por defecto. Porque esto es justo una prueba, usted puede dejar esos campos en sus valores predefinidos. Los campos son autoexplicativos, para que yo no necesito revisar cada uno.

4. El Modelo Enhebrando se pone al Apartamento. Deje esta escena cuando es. Otros modelos enhebrando incluyen Solo, Libre, y Ambos. Vea al Delphi ayudar para más información sobre enhebrar a modelos.

5. Verifique el Incluya Plan-Time Licencia cheque caja. Cuando esta opción se verifica, Delphi creará una licencia del plan-tiempo para el mando. La licencia del plan-tiempo les impedirá a otros programadores usar el mando a menos que ellos tienen la licencia.

6. Verifique el Incluya Versión Información cheque caja. Esto le permitirá que agregue info de la versión al mando vía las Opciones del Proyecto dialoge caja.

7. Verifique el también Incluya Sobre la caja de cheque de Caja. Cuando esta caja se verifica, Delphi creará automáticamente un Sobre la caja del diálogo para el mando. Pulse el botón OK para cerrar al ActiveX Mando Mago.

Delphi creará un archivo del proyecto (ButtonXControl1.bpr) y tres unidades para el proyecto. La primera unidad es los TButtonX clasifican unidad (ButtonXImp1.pas). La segunda unidad es el archivo de biblioteca de tipo para el mando, nombró ButtonXControl1_TLB.pas. Este archivo contiene la información que Delphi necesita crear la biblioteca del tipo para el mando. El tercer archivo, About1.pas, es la unidad para el Sobre la caja. Si usted quiere personalizar el Sobre la caja, usted puede hacer eso en este momento. El Sobre la caja es simplemente otro Delphi forman, para que se siente libre para personalizarlo de forma alguna le gusta.

---

NOTA: El info de la versión se requiere para que su ActiveX controla para trabajar en Visual Básico.

---

Construya, Registre, y Instale el Mando

Porque usted no está haciendo ninguna modificación al propio mando, usted puede saltar derecho a construir el mando y registrarlo. Éste es el mismo proceso por el que usted pasó cuando usted registró que los COM objetan usted creó antes. Un paso extra se requiere cuando llevando a cabo ActiveX controla, sin embargo, porque los mandos de ActiveX tienen una interface del plan-tiempo. Prueba esto:

1. Escoja Project|Build ButtonXControl1 del menú principal. Delphi construye el proyecto de ActiveX.

2. Escoja Run|Register ActiveX Servidor del menú principal. El mando de ActiveX es registrado y Delphi despliega una caja del mensaje que le dice que el OCX es registrado (los proyectos de ActiveX tienen una extensión predefinida de .OCX). Pulse el botón OK para despedir la caja del mensaje.

3. Escoja Component|Import ActiveX Mando del menú principal. Escoja ButtonXControl1 Biblioteca (Versión 1.0) de la lista de mandos instalados (lo tenía no realizado paso 2, esta entrada no habría estado presente en la lista de mandos instalados). El nombre de la clase del botón, TButtonX, muestra en la Clase nombres lista caja.

4. Póngale el campo de página de Paleta a ActiveX. Pulse el botón Instale para continuar.

5. El Instale la caja del diálogo se despliega. Usted va a instalar el mando en el usuario de Delphi predefinido paquete DCLUSR40.BPL. El campo de nombre de Archivo ya debe contener este paquete. Si no hace, lo escoge de la caja del combo. El campo de la Descripción dice los Componentes de Usuario de Delphi ahora. Pulse el botón el botón de OK para instalar el mando.

6. Pulse el botón Sí al mensaje caja considerar construyendo y instalando DCLUSR40.BPL. Pulse el botón OK cuando la caja del mensaje que confirma la instalación se despliega. El mando se instala ahora.

Pruebe el Mando de ActiveX

Ahora usted puede probar su nuevo mando de ActiveX. Primero, cree un nuevo proyecto.

---

NOTA: Cuando usted crea un nuevo proyecto, Delphi lo incitará ahorrar el archivo del paquete (DCLUSR40.DPK) y los ActiveX controlan proyecto. Si usted ahorra estos archivos depende de usted. Mi intención era a usted haga cree un ActiveX rápido. Hay realmente ninguna necesidad de ahorrar los archivos. Si, sin embargo, usted piensa que usted podría querer ahorrar los archivos para examinarlos después, ahorre los archivos.

---

Ahora siga estos pasos:

1. Localice la etiqueta de ActiveX en la paleta del Componente.

2. El último mando en la lista es el mando de ButtonX. Selecciónelo.

3. Ponga un mando de ButtonX en su forma. Aviso que el botón no tiene un subtítulo predefinido como un botón de VCL regular hace.

4. Cambie la propiedad del Subtítulo para Probar. El subtítulo del botón cambia así como el subtítulo de un botón de VCL cambiaría.

Note la lista de propiedades en el Inspector del Objeto. Ellos son principalmente las mismas propiedades usted vería en un botón de VCL (el ActiveX se creó de un VCL TButton después de todos), pero usted podría haber notado que la columna de Valor parece ligeramente diferente. Recuerde, éste es un mando de ActiveX y se piensa que es usado en cualquier ambiente que los organizadores los mandos de ActiveX. Por esa razón, algunos de los valores de propiedad se expresan de una manera más genérica.

5. Doble-pulse el botón el botón y usted encontrará que nada pasa. Un mando de ActiveX no tiene la capacidad para crear a un negociante de evento automáticamente que cuando usted doble-pulsa el botón el botón como un componente de VCL hace. En cambio, cambie a la página de Eventos y doble-pulse el botón la columna de Valor al lado del evento de OnClick. Un negociante de evento se genera. Teclee esta línea de código:

MessageDlg (`Hey, funciona! ', mtInformation, [el mbOK], 0);

6. Ejecute el programa y prueba el botón para asegurar que funciona. Cuando usted ha verificado que el botón trabaja, cierre el programa.

7. Plantee la forma y derecho-pulse el botón en el botón. Escoja Sobre del menú del contexto. El mando Sobre la caja se despliega. El Sobre la caja no se personaliza de forma alguna, pero usted puede regresar y puede hacer ese después si usted quiere (con tal de que usted ahorró el archivo más temprano).

---

NOTA: La idea detrás del uno-paso ActiveX es tomar un funcionamiento el componente de VCL y crear un mando de ActiveX de ese componente. La mayoría del tiempo, usted no tendrá que modificar el ActiveX codifica de forma alguna. Sin embargo, usted puede modificar ciertamente los ActiveX codifican después de que ha sido generado por Delphi si usted para que el deseo. Sea consciente, sin embargo, que si usted regenera que los ActiveX codifican de su componente de VCL original, se perderán todos los cambios hechos a la fuente de ActiveX.
NOTA: Usted puede crear ActiveX sólo controla del windowed VCL controla (los mandos derivaron de TWinControl o uno de sus descendientes). La lista de mandos de VCL de los que usted puede construir un mando de ActiveX contiene que todos instalaron componentes que específicamente se encuentran este criterio.

---

Unregister el Mando de ActiveX

Después de experimentar con su nuevo mando de ActiveX, usted debe unregister él para que no ocupe espacio en el Registro. Al unregister los ActiveX controlan, haga esto:

1. Escoja Component|Import ActiveX Mando del menú principal.

2. Seleccione el ActiveX en la lista de ActiveX instalado controla y pulsa el botón el Quite botón.

3. Pulse el botón Sí en la caja de diálogo de confirmación para tener unregister de Delphi el ActiveX.

Alternativamente, usted puede cargar los ActiveX proyectan (si usted lo salvara previamente) y escoge Run|Unregister ActiveX Servidor del menú principal.

---

NOTA: Si todo el resto falla, usted siempre puede localizar que los ActiveX controlan en el Registro y anulan la llave para ese mando. Use la función del hallazgo del Editor del Registro para encontrar la llave (búsqueda para el nombre del mando o su GUID). Naturalmente, usted quiere tener cuidado al revisar el Registro por mano.

---

ActiveForms creando

Creando un ActiveForm casi es tan fácil como creando un ActiveX de un componente de VCL existiendo. Naturalmente, usted puede crear un ActiveX complejo que contiene muchos componentes en una sola forma. Contrariamente a lo que su nombre implica, sin embargo, un ActiveForm puede ser acostumbrado a crear un ActiveX simple controle desde el principio (un botón coloreado, por ejemplo). En otras palabras, ActiveForms son no sólo por crear formas elegantes con docenas de cosas. Ellos son por crear solo-uso ActiveX también controla.

En esta sección, usted creará un ActiveForm. El ActiveForm tendrá dos revisar mandos, una etiqueta y un botón. El botón tomará que los volúmenes de los dos revisan mandos, los multiplican juntos, y despliegan el resultado en la etiqueta. Sí, yo sé que no exige a mucha imaginación pegar con el "multiplique dos números" la idea, pero mi meta es mostrarle cómo crear un ActiveForm con la cantidad mínima de código. Guardando el código a un mínimo le permite enfocar en el ActiveForm creación proceso sin se hundido abajo en código.

Cree el ActiveForm

Creando un ActiveForm es tan fácil que está asombrando. Siga estos pasos:

1. Cierre todos los proyectos y entonces escoge File|New del menú principal. El Almacén del Objeto se despliega.

2. Doble-pulse el botón el icono de ActiveForm. El Mago de ActiveForm se despliega. Esta caja del diálogo es idéntica al ActiveX Mando Mago salvo el hecho que el VCL Clase Nombre campo se encanece (no aplica aquí).

3. Entre en MyFormX en el Nuevo ActiveX Name el campo.

4. Cambie el campo de Unidad de Aplicación para leer MyFormImpl.pas.

5. Cambie el campo de Nombre de Proyecto a MyFormProj.dpr.

6. Deje juego Ejemplar al Hilo al Apartamento. Verifique el Incluya Versión Información cheque caja.

7. Pulse el botón el botón de OK para continuar.

Delphi crea las unidades requeridas y despliegues una forma.

Cree la Forma

Una forma de ActiveForm está justa una forma regular en esta fase. Usted puede agregar mandos a la forma, puede agregar código, y simplemente puede responder a los eventos gusta usted hace para una forma que pertenece a una aplicación. La una diferencia es que la barra del título en un ActiveForm no aparece en el propio mando. Está allí justo en momento del plan.

En este paso, usted agregará componentes y codificará para hacer los ActiveForm funcional. Cuando usted trabaja a través de los pasos, podría ayudar referirse para Figurar 15.8 después en el capítulo que muestra la forma completada. Yo voy darle los componentes primarios en los pasos siguientes y permitirlo termine el resto adelante su propio. Realice estos pasos:

1. Clasifique según tamaño la forma a aproximadamente 175 (anchura) a través de 275 (altura).

2. Agregue un Revise componente cerca del cima-centro de la forma (vea Figura 15.8). Cambie su propiedad del Nombre a Num1Edit, su propiedad del Texto a 0, y su Anchura a 50 o para que (la anchura exacta no es importante). Cambie la propiedad de AxBorderStyle al afbRaised.

3. Pulse el botón adelante el Revise componente y copíelo al Portapapeles; la pasta un nuevo componente del Portapapeles. Ponga el nuevo componente debajo del primero. Cambie su propiedad del Nombre a Num2Edit.

4. Ponga un componente de la Etiqueta debajo de los dos revise mandos. Esta etiqueta desplegará los resultados. Cambie la propiedad del Nombre de la etiqueta a ResultLbl y su propiedad del Subtítulo a 0.

5. Ponga un componente del Botón en la forma al derecho del Revise componentes. Cambie su Nombre a GoButton y su Subtítulo Ir!.

6. Doble-pulse el botón el botón y haga la OnClick evento negociante mirada así:

procedimiento TMyFormX.GoButtonClick(Sender: TObject);  

empiece  

  prueba  

    ResultLbl.Caption := IntToStr (  



      StrToInt(Num1Edit.Text) * StrToInt(Num2Edit.Text));  

  excepto  

    en EConvertError haga  

      ¡MessageDlg (`Oops! Usted entró en un valor inválido. ',  



        mtError, [el mbOK], 0);  

  extremo;  

extremo;

Este código simplemente los extractos los valores de los dos revisan mandos, los multiplica juntos, y despliegues el resultado en la etiqueta de ResultLbl. La excepción que maneja código despliega una caja del mensaje si el usuario entra en valores inválidos. Una excepción de EConverError se levantará si la conversión del texto al entero falla (si uno del revise mandos contiene texto, por ejemplo).

7. Agregue etiquetas adicionales para emparejar Figura 15.8.

8. Escoja Biblioteca de View|Type del menú principal. En la página de Información, cambie las Ayudas Atan campo a Mi Prueba la Biblioteca de ActiveForm. Éste es el texto que se desplegará en la Importación ActiveX que dialoga caja cuando usted instala el ActiveForm.

9. Ahorre el proyecto. Acepte el filenames predefinido. (Usted los especificó en el Mago de ActiveForm.) Figure 15.8 muestras la forma completada.

FIGURE 15.8. El ActiveForm terminado.

Construya, Registre, y Importe el ActiveForm

Ahora usted puede construir, puede registrar, y puede importar el ActiveForm. Cuando construyó, el ActiveForm está como cualquier otro mando de ActiveX. Porque usted ha hecho este varios tiempos ahora, yo no voy a revisar cada paso. Siga estos pasos:

1. Escoja Project|Build MyFormProj del menú principal.

2. Cuando el proyecto se construye, escoge Run|Register ActiveX Servidor del menú principal.

3. Escoja Component|Import ActiveX Mando del menú principal. Instale Mi Prueba la Biblioteca de ActiveForm (Versión 1) en el DCLUSR40 paquete. Instale a la página de ActiveX o cualquier otra página que usted escoge.

El ActiveForm se instala ahora como un mando de ActiveX.

Pruebe el ActiveForm

Ahora es tiempo para tomar el ActiveForm para un paseo de la prueba. Esto será bastante simple:

1. Cree una nueva aplicación.

2. Pulse el botón la etiqueta de ActiveX en la paleta del Componente y escoge MyFormX abrochan (el uno con el icono de Delphi predefinido).

3. Ponga un mando de MyFormX en su forma.

4. Ejecute el programa y pruebe fuera el ActiveX.

Eso es todos él hay a. ¡Con Delphi, grande-mirando mandos de ActiveX son una brisa para crear! No hay ambiente de desarrollo mejor simplemente por crear ActiveX controla que Delphi, no obstruya ninguno.

Cambiando la Paleta de ActiveX Bitmap

Finalmente usted querrá cambiar el bitmap del ActiveX del valor por defecto que Delphi proporciona a uno de su propio plan. Cambiando el bitmap requiere siguiendo estos pasos:

1. Cree un archivo del recurso binario (.RES) con Editor de la Imagen.

2. Cree un 24¥24 bitmap. Dé un nombre numérico al bitmap (2 por ejemplo).

3. Únase el archivo del recurso al proyecto de ActiveX con el recopilador de $R director. (Uniéndose recursos se discutió en Día 8, "Creando Aplicaciones en Delphi" y se discute más allá en Día 20, "Creando Componentes".)

4. Modifique los ActiveX clasifican rutina de creación de fábrica en la unidad de aplicación (el los .PAS de ActiveForm archivan). Una creación de fábrica de clase típica las miradas rutinarias así (está en la sección de la inicialización en el fondo de la unidad):

TActiveFormFactory.Create (  

    ComServer,  

    TActiveFormControl,  

    TMyFormX,  

    Class_MyFormX,  



    1, {el cambio este número. }  

    ` ',  

    OLEMISC_SIMPLEFRAME o OLEMISC_ACTSLIKELABEL,  

    tmApartment);

Note la línea que yo he marcado con un comentario. Este parámetro de TActiveFormFactory.Create es el número del recurso del bitmap usted necesidad desplegada en la paleta del Componente. Si usted ahorrara el nuevo bitmap con un nombre de 2, usted reemplazaría el 1 en este snippet del código con un 2.

5. Reconstruya, reregister, importe, y instale el ActiveForm de nuevo. Los nuevos bitmap deben presentarse ahora en la paleta del Componente.

Alternativamente, usted puede modificar los .RES del proyecto de ActiveForm archivan y cambian los bitmap nombrados 1 para parecerselo quieren.

Tejido que Despliega Mandos de ActiveX y ActiveForms

Uno de los grandes rasgos de ActiveForms es que usted puede usarlos en una página de Tejido. Para usar un ActiveForm en una página de Tejido, usted debe usar el Tejido Despliegue opción. El Tejido usando Despliega que requiere un servidor de Tejido, para que yo no puedo atravesarlo el proceso de despliegue de Tejido eficazmente. Yo puedo, sin embargo, délo un poco la visión en el proceso. Cuando usted escoge Tejido Despliegue, Delphi realiza dos tareas:

• Figuras los ActiveX controlan y copias el archivo al Tejido Despliega directorio designado

• Crea que un archivo de HTML que contiene el código necesitó cargar el mando de ActiveX

Las situaciones de estos archivos son determinadas por las opciones de despliegue de Tejido. Miremos ese próximo.

Opciones de Despliegue de tejido

Antes de que usted pueda usar Tejido Despliegue, usted debe poner las opciones de despliegue de Tejido. Para poner las opciones de despliegue de Tejido, escoja Project|Web Despliegue Opciones del menú principal. Las Opciones de Despliegue de Tejido dialogan la caja se despliega, como mostrado en Figura 15.9.

Figure 15.9. Las Opciones de Despliegue de Tejido dialogan caja.

Al fondo de las Opciones de Despliegue de Tejido dialoge la caja es una caja del cheque etiquetó Valor por defecto. Verifique esta caja que si usted quiere las escenas que usted ha especificado para ser los nuevos valores por defecto para los proyectos del futuro. La mayoría del tiempo, usted desplegará al mismo sitio de Tejido, para que usted querrá poner los valores por defecto probablemente que después de que usted tiene todo preparado justo la manera que usted lo quiere.

Página del proyecto: Directorios y Sección de URLs

Los Directorios y la sección de URLs es donde usted especifica la situación designado para su ActiveX. El campo del dir Designado se usa para especificar el directorio donde Delphi copiará el ActiveX después de que se construye. Este campo debe ser un directorio--no puede ser una situación de URL.

Si usted está como mí, usted no podría tener acceso directo al directorio donde su sitio de Tejido se localiza. (El Webster Royland de TurboPower guarda acceso controlado bastante herméticamente.) Si ése es el caso, usted tendrá que especificar un directorio local en este campo y entonces el uso más tarde su Tejido que publica software para publicar los archivos a su sitio de Tejido.

El campo de URL Designado se usa para especificar la página donde el ActiveX residirá en el servidor. Esta página es usada por Delphi cuando crea la página de HTML que muestra el mando. Por ejemplo, el archivo de HTML que Delphi creó para mí se muestra Listando 15.4. (Yo tenía que romper un par de líneas porque ellos estaban a favor demasiado largos de la página.)

LISTANDO 15.4. EL CÓDIGO de HTML GENERADO POR DELPHI PARA EL ARCHIVO de ACTIVEX.

<HTML>  

<H1> Delphi 4 ActiveX Prueba Página </H1><p>  



Usted debe ver su Delphi 4 formas o mandos   

empotrado en la forma debajo.  

<HR><center><P>  

<El OBJETO  

  classid = "clsid:52FB5B97-EDA3-11D1-B47B-0040052A81F8"  



  codebase = "http://www.home.turbopower.com/~kentr/test/MyFormProj.cab  

    #version=1,0,0,0"  

  width=275  

  height=175  

  align=center  



  hspace=0  

  vspace=0  

>  

</OBJECT>  

</HTML>  

Note el URL en la declaración del codebase. Éste es el camino yo tecleé en el campo de URL Designado de las Opciones de Despliegue de Tejido dialoge caja. A propósito, usted puede copiar la etiqueta del OBJETO entera del HTML Delphi-generado que codifica directamente a la fuente de HTML de su página de Tejido cuando usted consigue listo para desplegar su código de ActiveX oficialmente.

---

NOTA: El nombre del archivo de HTML creado por Delphi es el nombre del proyecto con una extensión de .htm.

---

El HTML dir campo de las Opciones de Despliegue de Tejido dialoga la caja se usa para especificar la situación donde Delphi pondrá que los HTML codifican genera (refiérase a Listar 15.4). Como con el campo del dir Designado, si usted no tiene acceso directo a los directorios de su sitio de Tejido, usted tendrá que especificar un directorio local y entonces publicar el HTML archiva a su sitio de Tejido.

Página del proyecto: Sección de las Opciones general

Esta sección es donde usted especifica las opciones de despliegue de Tejido globales. El Uso TAXI archivo condensación campo determina si el ActiveX está comprimido. Comprimiendo el ActiveX reduce el tamaño de su ActiveX y hace transmitiendo tanto más rápidamente el mando. Yo usé condensación del TAXI en el ActiveForm creó antes en el proyecto y el tamaño de ActiveX fue de 312KB en OCX forme a 204KB en forma del TAXI. Windows cuida de descomprimir automáticamente y registrar el ActiveX, no hay ninguna desventaja real así que a usar condensación del TAXI.

El Incluya el número de versión de archivo indica si Delphi debe incluir el número de la versión en la declaración del codebase (de nuevo refiérase a Listar 15.4). La etiqueta de la versión es optativa, para que usted no lo necesita específicamente. Note, sin embargo, que algunos browsers no cargarán el ActiveX si la etiqueta de la versión está presente (Navegante de Netscape con un ActiveX tapón-en, por ejemplo).

El Automóvil incremento descargo número incrementará el número de la versión automáticamente en el el info de la versión de ActiveX cada tiempo el ActiveX se despliega.

La Código señal proyecto opción juega un papel importante en despliegue de ActiveX. Cuando esta opción es adelante, Delphi codificará señal el ActiveX. El código firmar es el proceso de atar una firma binaria a un archivo. Esta firma binaria identifica la compañía que creó el ActiveX, entre otra información.

El código firmar es importante que porque el Explorador de Internet espera que ActiveX controle para ser código firmado. Si el nivel de seguridad de Explorador de Internet se pone a Alto o Elemento, cualquier mando de ActiveX que no es ningún código firmado no cargará. Simplemente ponga, si usted va a desplegar su ActiveX controla para que el público pueda usarlos, ellos deben ser código firmado.

El Código que Firma página de las Opciones de Despliegue de Tejido dialoga la caja contiene la información necesitó codificar señal el ActiveX. Delphi no proporciona las credenciales archivan o la llave privada necesitó codificar archivos de la señal. Para obtener un archivo de las credenciales y la llave privada, usted necesitará avisar Microsoft. Para más información, investigue el Microsoft Tejido sitio para los términos "Firma Digital" y "Autoridad del Certificado."

El Despliegue paquetes requeridos y Despliegue adicional archiva se usan opciones si usted ha construido su ActiveX con runtime empaqueta o si hay archivos adicionales que deben enviar con su mando. Si usted escoge cualquiera de estas opciones, usted debe especificar los paquetes o los archivos adicionales en los Paquetes y las páginas de los Archivos Adicionales de las Opciones de Despliegue de Tejido dialoge caja.

---

NOTA: Cuando en duda, pulse el botón las Ayudas abrochan en las Opciones de Despliegue de Tejido dialoge caja. La ayuda de Delphi explica cada uno de las páginas de esta caja del diálogo.

---

Tejido Despliega

Después de que usted puso las opciones del despliegue, usted está listo desplegar su ActiveX. Para desplegar el ActiveX, simplemente cargue los ActiveX proyectan y escogen Project|Web Deploy del Delphi el menú principal. Delphi construirá el ActiveX y desplegará basó en las escenas en las Opciones de Despliegue de Tejido dialoge caja. Si usted eligiera para usar condensación del TAXI, Delphi comprimirá el ActiveX también en un archivo del TAXI. Recuerde, si usted no tiene acceso directo a los directorios de su sitio de Tejido, usted tendrá que publicar el ActiveX y HTML archiva a su sitio de Tejido antes de que usted pueda probar el ActiveX.

El acto de desplegar el ActiveX es trivial--poniendo las opciones de despliegue de Tejido es la parte dura. Figure 15.10 muestras el ejemplo que ActiveForm creó corriendo antes en una página de Tejido.

FIGURE 15.10.La prueba ActiveForm que corre en una página de Tejido.

---

NOTA: Los mandos de ActiveX no tienen virtualmente ninguna restricción de seguridad. Tenga cuidado al transmitir mandos de ActiveX del desconocido (o unverified) las fuentes. Cuando transmitió, un mando de ActiveX tiene acceso a su sistema entero. Tenga igualmente cuidado al escribir sus propios mandos de ActiveX. Haga completamente efectivamente que su mando de ActiveX no hará nada que impactar las máquinas de otros usuarios negativamente.

---

Resumen

Yo no quedaré a usted--hay mucho más a COM y ActiveX que lo que se presenta aquí. Por ejemplo, yo no hablé sobre OLE. OLE, como ActiveX, es un subconjunto de COM. OLE agrega una capa a COM permitir a las aplicaciones unirse y empotrar OLE automatización servidores en una aplicación del recipiente. Todavía, usted aprendió un gran trato sobre COM y ActiveX hoy. Pretenciosamente, usted averiguó cómo crear COM objeta, ActiveX controla, y ActiveForms. Usted también aprendió un pedazo sobre Tejido Despliegue y cómo usarlo para desplegar sus mandos de ActiveX en una página de Tejido.

El Taller contiene preguntas del examen para ayudarle a solidificar su comprensión del material cubierta y ejerce para proporcionarle la experiencia usando lo que usted ha aprendido. Usted puede encontrar las respuestas a las preguntas del examen en Apéndice UN, "las Respuestas a las Preguntas del Examen."

Q&A

¿Q Do que yo tengo que entender los funcionamientos internos de COM para escribir mandos de ActiveX en Delphi?

Un Aunque un poco de comprensión de COM es ciertamente útil, no es vital a crear mandos de ActiveX con Delphi. Delphi lo hace fácil de crear mandos de ActiveX sin una comprensión en profundidad de COM.

¿Q lo que es una biblioteca del tipo?

Un UNA biblioteca del tipo es un archivo binario que describe las interfaces, el datos teclea, métodos, y clases en una biblioteca de COM (incluso ActiveX).

¿Q Are OLE y COM la misma cosa?

Un No. COM es la base en la que OLE se construye. OLE es mucho más complejo y enroscado que COM. Ciertamente OLE tiene más funcionalidad, pero OLE es una bestia hinchada que se evita mejor si posible.

Q yo noté algunos mandos de ActiveX ingenioso-pareciendo registrados en mi sistema, para que yo los instalé en la Delphi Componente paleta. Ellos se presentan en la paleta del Componente pero cuando yo intento usar uno de los mandos, yo consigo un mensaje del error sobre una licencia del plan-tiempo. ¿Por qué es eso?

Un para abreviar, no son autorizados que usted use esos mandos en un ambiente del plan (Delphi, por ejemplo). Los usuarios de ActiveX deben desplegar y deben registrar sus mandos de ActiveX en cada sistema que usa esos mandos. Impedir a cualquiera usar esos mandos libremente, los vendedores del mando requieren una licencia del plan-tiempo antes del mando puede usarse en momento del plan. Cuando usted compra un mando de ActiveX de un vendedor, usted consigue la licencia del plan-tiempo.

Q yo creé un mando de ActiveX y lo puse en mi forma. El programa trabajaba fino, pero ahora cuando yo intento ejecutar el programa que yo consigo una excepción que dice, la Clase no registró. ¿Por qué es eso?

Un Cada mando de ActiveX debe registrarse en el sistema en el que está usándose. Usted podría tener no registrado inadvertidamente los ActiveX controlan originalmente en su sistema algún tiempo después de usted instaló el mando. Al reregister el mando, cargue los ActiveX proyectan en Delphi y escogen Run|Register ActiveX Servidor. Alternativamente, usted puede registrar que los OCX archivan con la utilidad de TREGSVR.EXE.

Q yo creé y instalé un ActiveForm y todo fue fino. Después yo quise cambiar el ActiveForm. Yo no podría compilar los ActiveForm proyectan, sin embargo, porque yo seguí consiguiendo un error, no podría crear archivo del rendimiento MyProj.OCX. ¿Cuál está equivocado?

Un Usted necesita quitar el ActiveForm controla de la Delphi Componente paleta antes de que usted pueda reconstruir el mando. Cuando el mando se instala en Delphi, su archivo de OCX está cargado por el Delphi IDE y no puede borrarse.

Tejido de Q Despliega me confunde. Hay tantas opciones. ¿Soy yo el único que no entiende este material?

Un Ciertamente no. Después de que usted ha trabajado a través del Tejido Despliegue proceso unas veces, no es acobardando casi así cuando podría aparecer la primera vez que usted lo prueba.

Q yo estoy teniendo problemas que consiguen que mi ActiveX trabajara en una página de Tejido. Yo sigo recibiendo un error del Explorador de Internet cuando yo intento cargar la página. El error dice, Sus escenas actuales prohiben mandos de ActiveX. ¿Cuál está equivocado?

Un Su mando de ActiveX no es código firmado. Un mando de ActiveX debe ser código firmado ante el Explorador de Internet transmitirá el mando cuando las escenas de seguridad del usuario se ponen al medio o alto.

Examen

1. ¿Cuál es la base (o padre) la interface para todas las interfaces de COM?

2. ¿Cuál es un GUID?

3. ¿Qué pasa cuándo la cuenta de la referencia de un objeto de COM alcanza 0?

4. ¿Qué se usa el nombre de la utilidad de Delphi cuándo trabajando con bibliotecas del tipo?

5. ¿Cómo crea usted GUIDs cuándo escribiendo objetos de COM en Delphi?

6. ¿Qué escoge usted del Almacén del Objeto cuándo creando un ActiveX de un componente de VCL?

7. ¿Enlátelo que el uso Delphi-creó mandos de ActiveX en Visual Básico?

8. ¿Después de que su mando de ActiveX se construye y registró, cómo lo instala usted a la Delphi Componente paleta?

9. ¿Cómo hágalo el unregister un ActiveX que usted ha creado?

10. ¿Puede usar usted los mandos de ActiveX creados en Delphi en una página de Tejido?

Ejercicios

1. Cree que un COM simple objeta desde el principio. No es importante lo que el objeto de COM hace, sólo que usted pasa por los pasos de crearlo.

2. Escriba una aplicación de Delphi que usa el objeto de COM creada en ejercicio 1 (no se olvida de registrar el COM objete).

3. Cree un mando de ActiveX de un VCL el componente de TEdit. Instale el mando a la Delphi Componente paleta y úselo en una forma.

4. Si usted tiene acceso a Visual Básico, tome que el ActiveX creó en ejercicio 3 y lo usa en una aplicación de VB.

5. Cree un mando de ActiveForm de su propio plan.

6. Si usted tiene un sitio de Tejido, despliegue que el ActiveForm creó en paso 5 y lo despliega en una página de sitio de Tejido.

7. Crédito extra: Modifique el mando de ActiveForm creado en paso 5 para que use un bitmap de la costumbre en la Delphi Componente paleta en lugar del bitmap predefinido.

---

© Copyright, Macmillan Computadora Publicación. Todos los derechos reservaron.