La caja de herramientas (ToolBox) de Visual FoxPro 8.0 vista por dentro (Parte 2/2)

Autor: Beth Massi (www.BethMassi.com)

Texto original:
-- Inside the Visual FoxPro 8.0 ToolBox -- Mayo 2003
http://msdn.microsoft.com/library/en-us/dnfoxgen8/html/vfp8_toolbox.asp

Traducido por: Ana María Bisbé York (amby@telefonica.net)
Para PortalFox (www.PortalFox.com)

Se aplica a: Visual FoxPro 8.0

... Continuacion de La caja de herramientas (ToolBox) de Visual FoxPro 8.0 vista por dentro (Parte 1/2)

Crear comportamientos Add-In

Utilice add-in para extender el comportamiento de un tipo particular de elemento o categoría al llamar código de personalización que coloca en el ToolBox de la tabla contenido. Puede fácilmente crear un add-in que aparezca en el elemento del menú contextual para ejecutar acciones de menú. No necesita conocer todos los detalles de la arquitectura de la aplicación ToolBox para crear un add-in. Aunque haya saltado la discusión de la arquitectura, puede crear todavía un comportamiento add-in, y distribuir su conjunto de herramienta a otros desarrolladores. Aunque, para crear un add-in realmente útil, vea el siguiente ejemplo, que accede a propiedades y métodos de una clase de herramientas, discutido antes.

Comportamiento Add-in de elemento de herramienta.

El ToolBox admite muchos tipos de elementos y su comportamiento. Se describen en la Tabla 9.

Tabla 9. Elementos del ToolBox y su comportamiento.

Puede crear su propio comportamiento add-in además de estos comportamientos agregando los registros en la tabla de contenidos del ToolBox. Estos add-in aparecen como opción del menú contextual. Por ejemplo, puede crear un add-in para herramientas de proyectos que generen la aplicación a partir del proyecto. Puede querer una opción Build Application (Generar aplicación) que aparezca en el menú contextual para todos los elementos de proyecto en el ToolBox. Al seleccionar, esto genera un archivo .app a partir del proyecto. Este tipo de add-in sencillo requiere que introduzca registros en la tabla de contenido.

Abra su tabla ToolBox, y agregue un nuevo registro, en el cual pondrá la información que se muestra en la tabla 10.

 Tabla 10. Información necesaria para agregar una opción de menú contextual Build Application (Generar aplicación)

La letra A en el campo ShowType y PJX en el campo ToolTypeID indican al ToolBox que este es un add-in para un elemento de herramienta de proyecto. Por tanto la opción Build Application va a aparecer en el menú contextual para todas las herramientas de proyectos en el ToolBox. Especifique el código a ejecutar en el campo ToolData

LPARAMETERS oToolItem
LOCAL cFilename
cFilename = oToolItem.GetDataValue("filename")
IF FILE(cFilename)
   BUILD APP (FORCEEXT(cFilename, "APP")) FROM (cFilename)
ENDIF

Se pasa un parámetro, oToolItem, que es una referencia de la herramienta de objeto donde fue activado el add-in. Puede acceder a cualquier propiedad o método del elemento y ejecutar cualquier código. Este add-in en particular convierte el proyecto en un archivo .app. Cierre la tabla ToolBox y re-inicie el ToolBox. En el menú contextual para todas las herramientas de proyecto del ToolBox aparecerá Build Application (Figura 7)

Figura 7. Los Add-in pueden aparecer como opciones del menú contextual para un tipo de elemento en particular.

Otro ejemplo es crear una selección del menú para los elementos llamada Rename (Renombrar). Al seleccionar, este comando abre un cuadro de diálogo para introducir en nuevo nombre para la clase en la biblioteca de clases. Entonces se renombra la clase en la biblioteca de clases y se refresca la categoría. Abra su tabla ToolBox y agregue un registro nuevo para introducir la información que se muestra en la tabla 11.

Tabla 11. Información necesaria para agregar una opción de menú Rename en el menú contextual.

Luego, especifique el siguiente código en el campo ToolData

LPARAMETERS oToolItem
LOCAL cClassName, cClassLib, cNewName, oException
cClassName    = oToolItem.GetDataValue("classname")
cClassLib    = oToolItem.GetDataValue("classlib")
cNewName    = INPUTBOX("Nuevo nombre para la clase:", "Rename Class (Renombrar clase)", cClassName)
cNewName    = LOWER(ALLTRIM(cNewName))
IF!EMPTY(cNewName) AND !(cNewName == LOWER(cClassName))
   TRY
      RENAME CLASS (cClassName) OF (cClassLib) TO (cNewName)
      oToolItem.oEngine.RefreshCategory()
   CATCH TO oException
      MessageBox(oException.Message)
   ENDTRY
ENDIF

Este Add-in en particular renombra la clase en la biblioteca de clases y luego refresca la categoría que elimina el elemento anterior y la anterior referencia de clases. Entonces el add-in crea un nuevo elemento con la referencia a ese nuevo elemento. Puede llamar al método RefreshCategory() en el motor del ToolBox para realizar esto.

Suponga que desea agregar otro comportamiento que sea Copy Class (Copiar clase). Al seleccionarlo, se abre el cuadro de diálogo donde introducirá el nombre de la clase nueva. Entonces, crea una copia del elemento de clase en la biblioteca de clases y refresca la categoría para mostrar esta nueva clase como un elemento del menú. Y luego, agregue un registro nuevo e introduzca la información que se muestra en la tabla 12.

Tabla 12. Información necesaria para agregar una opción de menú Copy Class al menú contextual.

Luego, especifique el código a ejecutar en el campo ToolData:

LPARAMETERS oToolItem
LOCAL cClassName, cClassLib, cTempClassLib, oException, cNewName
cClassName= oToolItem.GetDataValue("classname")
cClassLib = oToolItem.GetDataValue("classlib")
cNewName  = INPUTBOX("Nombre de la clase nueva:", "Copy Class (Copiar clase)", 
cClassName)
cNewName  = LOWER(ALLTRIM(cNewName))
IF !EMPTY(cNewName) AND !(cNewName == LOWER(cClassName))
   cTempClassLib = ADDBS(SYS(2023)) + SYS(2015)
   TRY
      ADD CLASS (cClassName) OF (cClassLib) TO (cTempClassLib)
      RENAME CLASS (cClassName) OF (cTempClassLib) TO (cNewName)
      ADD CLASS (cNewName) OF (cTempClassLib) TO (cClassLib)      
      oToolItem.oEngine.RefreshCategory()
   CATCH TO oException
      MessageBox(oException.Message)
   ENDTRY
   ERASE (cTempClassLib + ".vcx")
   ERASE (cTempClassLib + ".vct")
ENDIF

Cierre y reinicie el ToolBox. Las opciones Copy Class y Rename Class aparecerán en el menú contextual de todas las herramientas de clase.

En lugar de desordenar el menú contextual principal con estos dos add-in nuevos, puede especificar que las opciones Rename Class y Copy Class se muestren en un submenú llamado Class Stuff (Cosas de clases). Puede hacer esto fácilmente agregando la información de la tabla 13 en un nuevo registro de la tabla de contenidos del ToolBox.

Tabla 13. Información necesaria para agregar un submenú Class Stuff.

Luego, actualice el campo ParentID de los add-in Rename Class y Copy Class con el UniqueID del add-in de Class Stuff MASSI.CLASSSTUFF. No es necesario agregar ningún registro nuevo en el add-in Class Stuff, porque el ToolBox automáticamente generará la jerarquía de los menús add-in buscando el campo ParentID (figura 8).

Figura 8. Puede agregar fácilmente opciones add-in en sus propios sub-menús.

Como puede ver, los add-in pueden ser muy poderosos, y al mismo tiempo, muy sencillos de crear. Hasta ahora hemos creado opciones estáticas de menú. ¿Qué pasa si desea crear una opción dinámica de menú? Por ejemplo, suponga que desea agregar un comportamiento add-in a una herramienta de librería de clases que muestre sus clases miembro en un menú add-in. Al seleccionarlo, este menú add-in abrirá el Diseñador de clases. En dependencia de la biblioteca de clases seleccionada, este menú puede contener elementos diferentes. Afortunadamente, el ToolBox proporciona flexibilidad para crear manualmente el menú add-in, si escribe M en el campo ShowType cuando define un registro add-in (Tabla 14).

Tabla 14. La letra M en el campo ShowType le permite especificar un menú contextual en su código.

En el campo ToolData para este menú add-in, el siguiente código crea elementos del menú dinámicamente basados en los nombres de clases contenidos en el VCX. Esto lo hace manipulando el objeto oContextMenu manualmente con el método AddMenu. Cuando el nombre de la clase es seleccionado del menú, invoca a otro add-in que marca como inactivo con el UniqueID = MASSI.MODICLASS. Este es el método del elemento del menú InvokeAddIn que llama al add-in MODICLASS y abre el Diseñador de clases para las clases seleccionadas.

*-- Add-Ins con ShowType == 'M' pasa el menú contextual como el segundo 
*-- parámetro, el que podemos utilizar para crear un menú dinámico. 
LPARAMETERS oToolItem, oContextMenu
LOCAL cFilename
LOCAL nClassCnt
LOCAL i
LOCAL ARRAY aClassList[1]
cFilename = oToolItem.GetDataValue("filename")
nClassCnt = AVCXCLASSES(aClassList, cFileName)
*-- Crea los elementos de menú dinámicamente 
FOR i = 1 TO nClassCnt
*-- Cuando el elemento de menu es seleccionado invocamos el registro add-in 
*-- MODICLASS para el nombre de la clase que fue seleccionada. 
   oContextMenu.AddMenu(aClassList[i, 1], ;
     [oRef.InvokeAddIn("MASSI.MODICLASS", "] + aClassList[i, 1] + [")])
ENDFOR

Ahora, para establecer el add-in MODICLASS, agregue un registro con la información que aparece en la tabla 15.

Tabla 15. Información necesaria para establecer un add-in MODICLASS

Observe que el campo Inactive está establecido en Verdadero (.T.) para evitar que este add-in esté visible en el ToolBox. Sin embargo, no evita que pueda ser llamado utilizando el método InvoqueAddin.

En el campo ToolData, el código es el siguiente:

LPARAMETERS oToolItem, cClassName
LOCAL cFilename
cFilename = oToolItem.GetDataValue("filename")
MODIFY CLASS (cClassName) OF (cFilename) NOWAIT

Cierre la tabla, para reiniciar el ToolBox. Al activar el menú contextual para un elemento de la biblioteca de clases, verá una opción de menú add-in Modify Class (Modificar clase) y su submenú contiene los nombres de las clases contenidas en la biblioteca (Figura 9). Al seleccionar una clase se abre la misma en el Diseñador de clases.

Figura 9. Puede crear menús add-in que son creados dinámicamente en tiempo de ejecución.

Categorías con comportamiento add-ins.

Los comportamientos Add-ins también se crean para tipos de categorías. La tabla 16 lista los tipos de categorías admitidas actualmente y sus comportamientos.

Tabla 16. Tipos de categorías admitidos actualmente y sus comportamientos add-in.

Puede además crear su propio comportamiento add-in además de estos comportamientos, agregando registros a la tabla de contenido del ToolBox. La única diferencia entre el campo ToolTypeID indica un tipo de categoría en lugar de un tipo de herramientas. Por ejemplo, para crear un comportamiento add-in para categoría general, entre CATEGORY.GENERAL para el valor de ToolTypeID.

Otros add-in

Puede crear además add-in que están disponibles en todos los menús contextuales para todos los elementos del ToolBox. Esto es útil si necesita un comportamiento que no sea específico para un solo tipo de herramienta. Por ejemplo, desea agregar Dock (Anclar) en el menú contextual para todos los elementos del ToolBox. Al seleccionarlo, este comando ancla el ToolBox en la parte derecha del escritorio. Puede hacer esto agregando un registro en la tabla 17.

Tabla 17. Información para agregar una opción Dock de menú contextual

Observe que el campo ToolTypeID está vacío. Esto orienta al ToolBox para colocar este add-in en todos los menús contextual. El código del campo ToolData se explica por sí solo:

LPARAMETERS oToolItem
*-- 0 = anclar a la izquierda, 1 = anclar a la derecha
_oToolbox.DockIt(1)

En lugar de crear add-in que aparezcan en los menús contextuales, puede crear comportamientos que se ejecuten cuando una categoría, elemento o el propio ToolBox sea abierto. En este caso, el campo ClassType para el add-in está establecido en el ONLOAD. Por ejemplo, entre un nuevo registro add-in con la información en la tabla 18.

Tabla 18. Información para agregar un comportamiento ONLOAD

En el campo ToolData, un simple mensaje se muestra para este ejemplo. Sin embargo, observe que se pasa al código, una referencia al motor ToolBox:

LPARAMETERS oToolboxEngine
Messagebox("Leyendo tabla Toolbox " + oToolboxEngine.ToolboxTable)

Al reiniciar el ToolBox, este código se ejecutará antes de que se muestre el formulario ToolBox.

Tenga en cuenta que todos estos registros add-in pueden ser distribuidos en la misma forma que se han descrito antes. De esta forma, puede fácilmente intercambiar con otros desarrolladores comportamientos add-in como parte de sus conjuntos de herramientas. Si crea herramientas de terceros, cumpla la misma convención de nombres que tienen las otras herramientas en conjunto incluyendo nombre de proveedor o producto junto a los IDs únicos así que puedan ser incluidos en los procesos de instalación y actualización.

Sobrescribir comportamientos y apoyar nuevos tipos de herramientas.

Como se ha discutido en la sesión anterior, los add-in son una vía sencilla para agregar comportamiento personalizado para un conjunto actual de los tipos del ToolBox y se distribuyen fácilmente como parte de un conjunto de herramientas. Además de los comportamientos add-in, el ToolBox puede extenderse de tal forma que puede sobrescribir comportamientos existentes o soportar su propia nueva herramienta y tipo de categorías. Para la mayoría de situaciones, los add-in cumplen lo que el desarrollador necesita, sin embargo, existen casos cuando necesita crear su propia implementación de clase de herramientas.

Puede extender o cambiar comportamientos actuales heredando su propio conjunto de herramientas desde un tipo de elemento o cambiando el comportamiento por código directamente en el elemento de herramienta de clase. Por ejemplo, puede crear una subclase de _dbftool llamada mydbftool para apoyar un comportamiento diferente de arrastrar y soltar para los elementos de tabla. O puede modificar la clase _bdftool directamente en la biblioteca de clases _toolbox.vcx. Puede que desee crear nuevos tipos de elementos heredando la clase padre apropiada, como _filetool o _tool, dependiendo del tipo de herramientas que necesita para realizar, o del nivel de control que necesita. Como regla, todos los elementos del toolbox que cree deben heredar de la clase _tool. Todas las categorías que cree debe heredar desde _category, y las categorías dinámicas deben heredar de _dynamiccategory.

El primer ejemplo describe cómo sobrescribir un comportamiento para todas las herramientas de un tipo determinado. Existen dos vías para lograr esto; modificar la clase de herramientas directamente en la biblioteca de clases _toolbox.vcx o crear una subclase de una herramienta de clases apropiada, y orientar al ToolBox para utilizar esta clase en su lugar. Si modifica directamente _toolbox.vcx, todos los elementos de este tipo toman el nuevo comportamiento. Esto incluye, el comportamiento del método apropiado en el _toolbox.vcx para la clase de herramientas que desea modificar. Al reiniciar el ToolBox, lee el nuevo código que introduzca.

Por ejemplo, suponga que desea modificar un comportamiento arrastrar y soltar del _dbftool. Actualmente, al soltar un elemento de tabla en un formulario, suelta un objeto grid basado en la configuración de registro, que se puede establecer en el cuadro de diálogo Opciones de Visual Foxpro la ficha Asignación de campos. Al seleccionar el tipo Múltiple. Si esto no se establece, suelta la clase base Grid de Visual FoxPro. Esto significa que cada elemento de tabla soltado, tendrá esta configuración establecida. Para establecer esta información para el elemento de la tabla, en unión con este acercamiento global, una opción es modificar la clase _dbftool para buscar el nombre de la clase grid y la biblioteca especificada en el elemento del cuadro de diálogo propiedades (Figura 10). Puede entonces especificar una clase particular para soltar para cada elemento de tabla en el ToolBox.

Figura 10. El _dbftool puede ser modificado para leer las propiedades de elementos para la biblioteca de clases y nombre para determinar qué objeto grid soltar a los diseñadores.

La primera aproximación para modificar este comportamiento es editar la clase _dbftool directamente en la biblioteca de clases _toolbox.vcx. Es buena idea hacer copia de seguridad de los archivos _toolbox.vcx y _toolbox.vct antes de comenzar. Ahora, abra el _dbftool en el diseñador de clases, y abra el método DropOnContainer. Puede ver el siguiente código:

#include "foxpro.h"
#include "toolbox.h"
LPARAMETERS oDropTarget, cSCXName, nXPos, nYPos
LOCAL cClassLib
LOCAL cClassName
LOCAL cPropertyList
LOCAL cOriginalObjName
LOCAL cFilename
*-- Mirar los valores de registro para el nombre de clase y la localización a 
*-- utilizar.
cClassLib  = THIS.GetRegistryValue("ClassLocation", INTELLIDROP_KEY + "Multiple")
cClassName = THIS.GetRegistryValue("ClassName", INTELLIDROP_KEY + "Multiple")
*-- Obtener el valor de la propiedad 'filename' para este elemento. 
*-- Ex. 'C:MYDATATABLE1.DBF'
cFilename  = NVL(THIS.GetDataValue("filename"), '')
*-- Si el valor del registro no está establecido, utilice la clase base Grid de 
*-- Visual FoxPro
IF EMPTY(cClassName) OR !FILE(cClassLib)
   cClassLib = ''
   cClassName = "Grid"
ENDIF
*-- Obtener el valor de la propiedad 'objectname' para este elemento.
*-- Ejemplo: 'MyGrid'
cOriginalObjName = NVL(THIS.GetDataValue("objectname"), '')
IF EMPTY(cOriginalObjName)
   cOriginalObjName = "grd" + JUSTSTEM(cFilename)
ENDIF
*-- Crear la lista de propiedades especificadas en el diálogo propiedades.
*-- Todas las propiedades de escritura se establecerán cuando es soltado el 
*-- objeto.
cPropertyList = TEXTMERGE( ;
 [RecordSourceType=1] + CHR(10) + ;
 [RecordSource=<<JUSTSTEM(cFilename)>>] + CHR(10), ;
 .F., "<<", ">>") + ;
 CHR(10) + THIS.EvalText(NVL(THIS.GetDataValue("properties"), ''))
*-- Suelta el objeto en el diseñador
THIS.DropObject(oDropTarget, cSCXName, nXPos, nYPos, cClassName, ;
cClassLib, '', cOriginalObjName, cPropertyList, '', '', cFilename)

Es importante entender, que este método está leyendo el registro para el nombre de clase y localización, así que puede especificar esa información en los parámetros cClassName y cClassLib del método DropObject. Entonces, todo lo que necesita hacer, es establecer esas dos variables con la información correspondiente. Puede hacer esto con string parking. Las propiedades de un elemento pueden ser obtenidas llamando al método GetDataValue y se le pasa el nombre del valor a recibir, en este caso, propierties. Esto devuelve una cadena que contiene una lista delimitada por retornos (carriage return) de las propiedades de los elementos en el formulario de PropertyName=Value. Todo lo que necesita es buscar for Class= and ClassLibrary= para recibir el valor.

#include "foxpro.h"
#include "toolbox.h"
LPARAMETERS oDropTarget, cSCXName, nXPos, nYPos
LOCAL cClassLib
LOCAL cClassName
LOCAL cPropertyList
LOCAL cOriginalObjName
LOCAL cFilename
m.cFilename  = NVL(THIS.GetDataValue("filename"), '')
LOCAL lcProps
lcProps = THIS.GetDataValue("properties")
*-- Dónde están especificadas ambas propiedades?
IF "class=" $ LOWER(lcProps) AND "classlibrary=" $ LOWER(lcProps)    
*-- Split (Dividir) las propiedades en matrices para buscarlo facilmente
LOCAL ARRAY laProps[1]
ALINES(laProps,LOWER(lcProps))
*-- Buscar la propiedad de clases y tomar el valor
m.cClassName = THIS.EvalText( ;
SUBSTR(laProps[ASCAN(laProps, "class=")],LEN("class=")+1))
*-- Buscar la propiedad classlibrary y tomar el valor
m.cClassLib = THIS.EvalText( ;
SUBSTR(laProps[ASCAN(laProps, "classlibrary=")],LEN("classlibrary=")+1))
ELSE
*-- Si no especificamos las propiedades del elemento, utilice la 'Multiple' 
*-- registry setting (configuración de registro “Múltiple”)
m.cClassLib  = ;
THIS.GetRegistryValue("ClassLocation", INTELLIDROP_KEY + "Multiple")
m.cClassName = ;
THIS.GetRegistryValue("ClassName", INTELLIDROP_KEY + "Multiple")
ENDIF
IF EMPTY(m.cClassName) OR !FILE(m.cClassLib)
   m.cClassLib = ''
   m.cClassName = "Grid"
ENDIF
.
.
.

Este código busca primero las propiedades para Class y ClassLibrary. Si se encuentran estas propiedades, establece las variables adecuadas, que son entonces pasadas al método DropObject. El método EvalText evalúa el valor de la propiedad de tal forma, que pueda incluir funciones y variables en el valor de propiedades del elemento. Por ejemplo, puede especificar la localización de la biblioteca de clases en cuadro de diálogo propiedades del elemento como: (HOME()+"FFC\_BASE.VCX") para utilizar las Foundation clases de Visual FoxPro. Puede verificar sus cambios cerrando la biblioteca de clase y abriendo el ToolBox. Específicamente una clase grid para una de sus herramientas de tablas en las propiedades del elemento y luego soltar el elemento en el formulario. Verá que el objeto grid que es soltado, ahora está basado en la clase que le haya especificado.

En lugar de modificar la biblioteca de clases _toolbox.vcx, puede crear una subclase de _dbftool en una nueva biblioteca de clases. Modifique luego el campo de la tabla ToolType para especificar nueva información de clase para el tipo de herramienta Tabla. Si lo hace así, los campos Class y Classlib en la tabla ToolType se copian a la tabla de contenidos del ToolBox para este elemento. Por tanto, algunos elementos existentes se refieren aun a la clase padre. Cualquier elemento nuevo que cree, sin embargo, se referirá a su nueva subclase. Puede crear un conjunto de herramientas, en el cual, herramientas individuales pueden tener comportamientos sobrepasados (overriding behaviors) Esto es especialmente ventajoso si terceros suministradores quieren herramientas en sus conjuntos de herramientas que sigan algún comportamiento especial; pero no desean sobrescribir este comportamiento para todas las herramientas de este tipo. En este caso, no necesita tocar la tabla ToolType. Sólo necesita entrar la información de Class y ClassLib manualmente en la tabla de contenidos de ToolBox para este elemento en particular y luego distribuir la biblioteca de clases.

Restaure la biblioteca de clases _toolbox.vcx y cree una nueva herramienta llamada mydbftool basada en _dbftool. Cree esta clase en una nueva biblioteca de clases llamada MyTollBox.vcx y guárdela en la misma carpet del _toolbox.vcx.

CREATE CLASS mydbftool OF MyToolbox.vcx AS _dbftool FROM _toolbox.vcx

Modifique el método DropOnContainer para incluir los cambios de código y salvar y cerrar la clase. Luego, visualice la tabla Tooltype y localice el registro donde el campo Tooltype = Table (UniqueId = DBF). Establezca el campo Classname = mydbftool y el campo ClassLib = c:\Program Files\Microsoft Visual FoxPro 8\Toolbox\MyToolbox.vcx. (nombre y ruta de la biblioteca de clases). Cierre la tabla ToolType y reinicie el ToolBox. En el formulario Customize (Personalizar) ToolBox, agregue un elemento, seleccione File como su type (tipo) y localice una tabla (archivo .dbf). Abra las propiedades del elemento, especifique su Class y ClassLibrary de una cuadrícula a soltar, y luego arrastre y suelte el elemento en el formulario. El grid está basado en la clase que ha especificado. Sin embargo, si tiene elementos de tabla existentes en su ToolBox, el comportamiento de aquellos elementos no cambiará. Puede ver esto abriendo su tabla de contenido de ToolBox y mirando los campos ClassName y ClassLib.

Este mismo método es utilizado para agregar un nuevo tipo de herramienta al ToolBox. Primero, cree su clase de herramientas heredando de una herramienta determinada en la jerarquía. Si el tipo que está agregando, está basado en un tipo de archivo particular que no exista, hereda de la clase _filetool. Entonces escriba el código apropiado para su nueva clase de herramientas. Finalmente, agregue su nuevo tipo de herramienta en la tabla ToolType, asegúrese de que especifica un único ID para su nueva herramienta. Se recomienda que siga el formato NombreDeCompania.ToolName.

Para la clase mydbftool, en la tabla ToolType cree su propio tipo llamado Extended table, en lugar de especificarlo como clase de tipo de tabla. Agregue un registro a la tabla ToolType como se muestra en la tabla 19, e introduzca los valores de los campos relevantes (Puede ver la tabla ToolType descrita anteriormente en este artículo para ver la descripción de los campos de la misma.)

Tabla 19. Información para crear su propio tipo de Extended table (Tabla extendida)

Cierre la tabla y reinicie el ToolBox. Debido a que el campo ShowNew está establecido en .T. (Verdadero), cuando seleccione Add Item (Agregar elemento) en el cuadro de diálogo Customize ToolBox, verá el nuevo tipo de herramienta listado (Figura 11).

Figura 11. Los nuevos tipos de herramientas que son creados, pueden ser mostrados en el cuadro de diálogo Add Item.

Después que seleccione el tipo Extended Table, la hoja propiedades del elemento se abre para que pueda introducir todos los campos requeridos para el elementos, tales como, Item name (nombre del elemento), Object name (nombre del objeto), y File name (nombre del archivo). Además, puede entrar las propiedades ClassLibrary y Class en el editor de propiedades. La hoja de propiedades se muestra inmediatamente porque el campo PropsSheet está establecido en .T. (Verdadero). Al arrastrar y pegar un elemento Extended Table al diseñador, es soltado un grid basado en la clase que haya especificado. Sin embargo, cualquier elemento de tabla que agregue en el ToolBox mantendrá el comportamiento predeterminado.

Soportar nuevos tipos de categorías

Crear nuevas categorías, es el mismo proceso que crear un nuevo tipo de herramientas. Crear la clase categoría y agregar un registro en la tabla ToolType. Tipicamente, agrega una nueva categoría porque necesita cumplimentar determinadas acciones cuando esta categoría sea abierta. Algunas de las categorías built-in ya hacen esto: por ejemplo: una categoría de carpeta dinámica crea un elemento de herramienta al vuelo, cuando es abierto. Una categoría dinámica tiene algunas características especiales que usted explorará.

Al crear categorías dinámicas, los elementos en las categorías no están representados físicamente en la tabla de contenidos del ToolBox. En su lugar, son guardados en memoria, en un cursor. Así, si busca en su tabla de contenidos ToolBox, los elementos mostrados en una categoría basada en carpeta dinámica, no verá estos registros. Esto es además, por qué las categorías dinámicas muestran el mensaje "Dynamic Category - click on Category Properties to modify" ("Categoría Dinámica – haga clic en Category Propierties (Propiedades de las categorías) para modificarlas). En el elemento del grid Customize (Personalizar) ToolBox. Para crear y manipular estos elementos de herramientas virtuales, puede mirar en el motor del ToolBox, algún método especial que guarde y restaure los elementos virtuales.

Por ejemplo, puede crear una categoría environment (entorno) que muestra como elemento de herramienta todos los conjuntos de entorno y proyectos guardados en el Administrador de entorno de Visual FoxPro. El Administrador de entorno es una nueva herramienta en el Visual FoxPro 8.0, que controla los grupos de entorno, de tal forma que puede rápida y fácilmente, cambiar la configuración de entorno y ejecutar script para establecer los proyectos. Puede asociar los proyectos con los conjuntos de entorno. Se accede típicamente desde el Administrador del panel de tareas; pero puede ejecutar además EnvMgr.app como una aplicación stand-alone. De hecho, puede pasar el nombre del conjunto de entorno para ejecutar automáticamente y puede especificar si ejecutar en modo silencioso (quiet mode). Puede además pasar el nombre de un proyecto específico para abrir que se aplicará los parámetros de entorno y entonces se abre el administrador de proyectos. Si lo ejecuta en modo silencioso, el Administrador de entorno no mostrará un cuadro de mensaje cuando se ejecuta el conjunto de entorno.

DO (HOME()+"ENVMGR.APP") WITH "Environment Set 1", .T.

Seguramente quiere, que cada elemento en la categoría sea creado dinámicamente y muestre el conjunto de entorno y cualquier nombre de proyectos para leer la tabla de Administrador de entornos (EnvMgr.dbf). Cuando el elemento es seleccionado se llama el entorno, pasa el ID del conjunto o proyecto. Puede además establecer dos opciones en la categoría: la ruta de la tabla del Administrador de entorno y, si desea ejecutarlo en modo silencioso. La ruta de la tabla que contiene el conjunto de entorno predeterminada es: \Documents and Settings\UserName\Application Data\Microsoft\Visual FoxPro 8\EnvMgr.DBF, or HOME(7)+"EnvMgr.dbf". Si esta opción está en blanco, se asume la carpeta predeterminada.

Lo primero que hay que hacer, es crear una categoría de administrador de entorno, que es una subclase de _dynamiccategory.

CREATE CLASS EnvMgrCategory OF MyToolbox.vcx AS _DynamicCategory FROM _toolbox.vcx

Al crear su propio tipo de categoría dinámica, existen dos métodos a sobreescribir: OnCreateDataValues y OnRenderCategory. En el método OnCreateDataValues al especificar las opciones que debe proporcionar esta categoría. Esta información se muestra en la hoja de propiedades de la categoría. Puede especificar una opción a ejecutar en modo silencioso, y una opción para especificar la tabla de Administrador de entorno a utilizar. Idealmente, puede utilizar la tabla de recursos de Visual FoxPro para obtener esta información. Sin embargo, para este ejemplo, si la propiedad está en blanco, es asumida la ruta predeterminada. Debe recordar, que para crear estas opciones, todo lo que necesita hacer es llamar al método AddDataValue. El código del método OnCreatDataValues debe contener lo siguiente:

*-- Agregar todas las propiedades dinámicas de una categoría dinámica.
DODEFAULT()
*-- Agregar nuestras propiedades adicionales.
THIS.AddDataValue("quietmode", .F., "Run quietly", '', .F., "cfoxcheckbox")
THIS.AddDataValue("envfile", '', "Env. Manager Table", '', .F., "cfoxfilename")

Luego, escriba el código en el método OnRenderCategory para crear cada elemento de herramienta en la categoría. Primero, consulte la tabla del administrador de entorno para todos los conjuntos de entornos y proyectos. Para cada conjunto o proyecto encontrado, cree un objeto de herramienta que se muestra en la categoría. Cuando es seleccionada esa herramienta en esa categoría, ejecute EnvMgr.app, pasándole el UniqueID del elemento, y un segundo parámetro para indicar si se ejecuta en modo silencioso. Para facilitar este comportamiento, los elementos de herramienta que cree dinámicamente son una instancia de la herramienta de aplicación que indica en la tabla ToolType, donde ToolType. UniqueID = "APP". Estos tipos de herramientas actualmente referencia la clase _apptool en la biblioteca de clases _toolbox.vcx. Debido a que el tipo de herramienta aplicación ya tiene un comportamiento para ejecutar una aplicación cuando es seleccionado, todo lo que debe hacer es establecer la propiedad de nombre de archivo de la aplicación Administración de entorno. Puede agregar paréntesis alrededor del nombre de la propiedad tal que pueda ser evaluada en tiempo de ejecución. Puede entonces, llamar fácilmente a la aplicación Administrador de entorno con parámetros. Por ejemplo, para ejecutar un conjunto de entorno en modo silencioso, cree manualmente un elemento de aplicación y establezca la propiedad filename como sigue:

(DO (HOME() + "ENVMGR.APP") WITH "_0VK0QENFH", .T.) 

Sin embargo, cuando crea un elemento de aplicación manualmente, crea un registro físico en la tabla de contenidos del ToolBox. Estas categorías necesitan crear una aplicación virtual, que son mostradas dinámicamente cuando la categoría es abierta. Puede administrar sus conjuntos de entorno en un lugar, el Administrador de entorno, y la categoría recoge los cambios automáticamente. Para crear elementos de herramienta virtual, utilice dos métodos del motor del ToolBox: GetVirtualToolObject y SaveVirtual. Estos métodos manipulan un cursor interno de herramientas virtuales llamado VirtualCursor. Una referencia a un motor, puede obtenerse a través de la propiedad oEngine de una herramienta de clase. Estas herramientas, pueden ser agregadas a la colección oToolCollection que se pasa en el método OnRenderCategory.

El método OnRenderCategory contiene lo siguiente:

*-- Cargar la colección oToolCollection pasada con los objetos de herramientas
*-- en esta categoría – en este caso, un objeto de categoría para 
*-- cada conjunto de entorno o proyecto definido en el EnvMgr.dbf table.
LPARAMETERS oToolCollection
LOCAL oToolObject, cEnvFile, nCnt, i, oToolType, lQuietMode 
LOCAL cToolTypeID, cToolCaption, cToolTip, cFileName
LOCAL ARRAY aEnvList[1] 
DODEFAULT(oToolCollection)
*-- Tomar el valor de la propiedad quietmode 
lQuietMode = NVL(THIS.GetDataValue("quietmode"), .F.)
*-- Tomar el valor de la propiedad envfile  
cEnvFile = THIS.EvalText(NVL(THIS.GetDataValue("envfile"), ''))
IF EMPTY(cEnvFile)
 cEnvFile = HOME(7) + "envmgr.dbf"
ENDIF 
IF FILE(cEnvFile)
 *-- Agarre todo el conjunto de entorno ('E') y proyectos ('P') desde la  
 *-- tabla de administrador de entorno
 SELECT UniqueID, EnvType, SetName ;
  FROM (cEnvFile) ;
  WHERE (EnvType == 'E' OR EnvType == 'P') ;
  ORDER BY SetName ;
  INTO ARRAY aEnvList  
  nCnt = _TALLY  
  cToolTypeID = "APP" 

  FOR  i = 1 TO nCnt
    *-- Crea un objeto de herramienta virtual que es identificado en 
    *-- ToolType.dbf as "APP". 
    *-- (Recuerde, Tooltype es donde la clase y la biblioteca de clases es 
    *-- especificada.)
    *-- El Segundo parámetro es el encabezado para el objeto de herramienta y 
    *-- el tercer parámetro especifica el tipo de herramientas. 
    cToolCaption    = RTRIM(aEnvList[i, 3])
    cToolTip   = cToolCaption
    oToolObject = THIS.oEngine.GetVirtualToolObject(cToolTypeID, ;
                     cToolCaption, cToolTip )
    IF !ISNULL(oToolObject)    
        IF lQuietMode
         *-- Para ejecutar en modo silencioso, pasa .T. (Verdadero) y el segundo
         *-- parámetro para EnvMgr.App
          cFileName = [(DO "] + HOME() + ;
                     [EnvMgr.app" WITH "] + aEnvList[i, 1] + [", .T.)] 
        ELSE
          cFileName = [(DO "] + HOME() + ;
                  [EnvMgr.app" WITH "] + aEnvList[i, 1] + [")] 
        ENDIF
       *-- Establece la propiedad filename en su herramientas de 
       *-- aplicación virtual.
       oToolObject.SetDataValue("filename", cFileName )
       *-- Salva el objeto de herramienta virtual en el VirtualCursor
       THIS.oEngine.SaveVirtual( oToolObject)    
    *-- Agregue la herramienta a la colección de tal forma que pueda mostrar en
    *-- la categoría.   
       oToolCollection.Add( oToolObject)
    ENDIF
  ENDFOR
ENDIF
RETURN

Note cómo la propiedad QuiteMode de la categoría, es requerida, entonces, puede establecer la propiedad filename en el objeto herramienta de forma apropiada. Puede crear su propio tipo de herramientas al subclasear (subclassing) el _apptool y tener el código para hacer algo de esto en el objeto herramienta como tal.

El paso final es agregar el nuevo tipo de categoría a la tabla ToolType. Agregue un registro a la tabla ToolType y entre el campo relevante como se indica en la tabla 20.

Tabla 20. Información para agregar un nuevo tipo de categoría para el Administrador de entorno.

Ahora, reabra el ToolBox, y agregue una categoría del Administrador de entorno seleccionando Environment Manager (Administrador de entorno), el que es listado como una selección disponible en la lista de tipos de categorías. Escriba el nombre de la categoría y haga clic en OK. Aparece la hoja de propiedades de la categoría, así que puede seleccionar la ruta de la tabla del Administrador de entorno y especificar si se puede ejecutar en modo silencioso (Figura 12).

Figura 12. La nueva categoría que crea, muestra sus propiedades personalizadas en el cuadro de diálogo Category Properties (Categoría de las propiedades).

Abra la categoría, y podrá ver el elemento de herramienta aplicación para cada conjunto de entorno y proyecto en el Administrador de entorno (Figura 13). Haga clic en una herramienta de aplicación para ver su conjunto de entorno.

Figura 13. El tipo de categoría Administrador de entorno que ha creado muestra su conjunto de entorno y proyectos como una aplicación de herramienta virtual.

Conclusiones

En este artículo, aprendió cómo crear y distribuir conjuntos de herramientas a sus equipos de desarrollo y cómo crear paquetes de instalación de conjuntos de herramientas. Aprendió además, sobre la arquitectura del ToolBox y lo fácil que es extender el ToolBox, creando poderosos comportamientos add-in. Además, ha descubierto cómo sobrescribir comportamientos existentes, y agregar su nuevo tipo propio de herramienta y categoría.