Validar CIF (solo España)

Para la validación de un C.I.F. se deben realizar una serie de operaciones matemáticas, para lo cual, de los 9 caracteres que componen dicho código se utilizan únicamente los caracteres numéricos situados en las posiciones 2 a 8. Sirva como ejemplo el C.I.F. que se muestra en el gráfico sobre este texto, en el que dichas cifras serían 4635353

En primer lugar, deben sumarse las cifras existentes en los lugares pares, con lo que se obtendrá un valor (R1). Así pues: R1 = 6 + 5 + 5 = 16.

En segundo lugar, cada cifra en lugar impar se multiplica por 2, sumándose las dos cifras del producto si este fuera superior a 9:

4 x 2 = 8;
3 x 2 = 6;
3 x 2 = 6;
3 x 2 = 6.

Los resultados obtenidos se suman entre sí, con lo que se obtiene un segundo valor (R2). De esta forma: R2 = 8 + 6 + 6 + 6 = 26.

Seguidamente se suman R1 y R2, con lo que se obtiene R:

R = R1 + R2 = 42.

Una vez calculado R, de esta cantidad sólo es útil el valor de la cifra de las unidades (U), en este caso: U = 2.

Se halla ahora la diferencia (D) de restar a 10 el valor de U, con lo que D estará dentro del rango de valores entre 1 y 10. En este último caso, se cambiará su valor a cero. En el ejemplo:

D = 10 - 2 = 8.

Si la sociedad es de tipo privado y española, el dígito hallado será el carácter de validación y ocupará la última posición del C.I.F.; en cualquier otro caso, dicho carácter deberá corresponder a una letra, por lo que se aplicará la siguiente tabla de conversión:

1 2 3 4 5 6 7 8 9 0
A B C D E F G H I J

Rafael Bilbao Aragonés

Validar el número de CUIT o CUIL

¿Cómo validar el número de C.U.I.T. o C.U.I.L.? (Solo para Argentina)

En la República Argentina a todas las personas físicas o jurídicas, se le otorga un número conocido como Clave Única de Identificación Tributaria (C.U.I.T.) o Clave Única de Identificación Laboral (C.U.I.L.).

Para saber si este número es correcto utilizaremos la función:

? _ValidaCUIT("20-16886271-8")

*------------------------------------------------
* FUNCTION _ValidaCUIT(tcCUIT)
*------------------------------------------------
* Valida el número de CUIT o CUIL
* USO: _ValidaCUIT(<99-99999999-9>)
* RETORNA: Lógico
*------------------------------------------------
FUNCTION _ValidaCUIT(tcCUIT)
  LOCAL lnSuma, llRet
  IF EMPTY(tcCuit)
    llRet = .T.
  ELSE
    IF TYPE('tcCuit') = 'C' AND LEN(tcCuit) = 13
      lnSuma = VAL(SUBS(tcCUIT,11,1)) * 2 + ;
        VAL(SUBS(tcCUIT,10,1)) * 3 + ;
        VAL(SUBS(tcCUIT,9,1)) * 4 + ;
        VAL(SUBS(tcCUIT,8,1)) * 5 + ;
        VAL(SUBS(tcCUIT,7,1)) * 6 + ;
        VAL(SUBS(tcCUIT,6,1)) * 7 + ;
        VAL(SUBS(tcCUIT,5,1)) * 2 + ;
        VAL(SUBS(tcCUIT,4,1)) * 3 + ;
        VAL(SUBS(tcCUIT,2,1)) * 4 + ;
        VAL(SUBS(tcCUIT,1,1)) * 5
      llRet = VAL(SUBS(tcCUIT,13,1)) = ;
        IIF(MOD(lnSuma,11) = 0, 0, 11-MOD(lnSuma,11))
    ELSE
      *--- No es Char o no tiene el largo correcto
      llRet = .F.
    ENDIF
  ENDIF
  RETURN llRet
ENDFUNC

Luis María Guayán

Calcular la letra de un DNI (para España)

Facil rutina para calcular la letra del DNI, (valido solo para España) ...

************************************************************
*
* Funcion: LETRADNI
*
* Dado un DNI devuelve la letra
*
* Parametros:
*
* tndni - DNI en formato numerico
*
* Ejemplos:
*
* letra =letradni(32415874)
*
* Retorno
*
* caracter - la letra de verificacion
*
* Fecha de Creacion  : 21/08/2001 Pablo Roca
* Ultima Modificacion: 21/08/2001 Pablo Roca
*
************************************************************
FUNCTION letradni
LPARAMETERS tndni
RETURN SUBSTR("TRWAGMYFPDXBNJZSQVHLCKE",MOD(tndni,23)+1,1)

Pablo Roca

Algunas funciones de la API de Windows

Por Luis María Guayán

---

Algunas funciones de la API de Windows usadas desde Visual FoxPro

Conectandose a la red desde Visual FoxPro

Funciones de la API de Windows para conectarse, desconectarse e interrogar sobre una conexión de red. Estas funciones son:

• Interroga sobre una conexión de red...: WNetGetConnection
• Añade una nueva conexión de red......: WNetAddConnection
• Cancela una conexión de red.............: WNetCancelConnection

Ahora podemos usar directamente funciones definidas por el usuario para una fácil implementación en nuestras aplicaciones de Visual FoxPro. Estas tres funciones se describen a continuación:

*----------------------------------------
* FUNCTION GetConnection(lcDrive)
*----------------------------------------
* Retorna el nombre de la PC y recurso
* compartido de una conexión de red
* PARAMETROS: lcDrive
* USO: ? GetConnection("K:")
*----------------------------------------
FUNCTION GetConnection(lcDrive)
DECLARE INTEGER WNetGetConnection IN WIN32API ;
STRING lpLocalName, ;
STRING @lpRemoteName, ;
INTEGER @lpnLength
LOCAL cRemoteName, nLength, lcRet, llRet
cRemoteName=SPACE(100)
nLength = 100
llRet = WNetGetConnection(lcDrive,@cRemoteName,@nLength)
lcRet = LEFT(cRemoteName,AT(CHR(0),cRemoteName)-1)
RETURN lcRet
ENDFUNC

*----------------------------------------
* FUNCTION AddConnection(tcDrive,tcResource,tcPassword)
*----------------------------------------
* Conecta un recurso compartido a la unidad tcDrive
* USO: ? AddConnection("Z:","PC_REMOTARECURSO")
*----------------------------------------
FUNCTION AddConnection(tcDrive,tcResource,tcPassword)
LOCAL lnRet
DECLARE INTEGER WNetAddConnection IN WIN32API;
STRING @lpzRemoteName, ;
STRING @lpzPassword,;
STRING @lpzLocalName
IF PARAMETERS() < 3
lnRet = WNetAddConnection(@tcResource,0,@tcDrive)
ELSE
lnRet = WNetAddConnection(@tcResource,@tcPassword, @tcDrive)
ENDIF
IF lnRet # 0
RETURN "Error " + ALLT(STR(lnRet)) + ;
" al conectar el drive " + tcDrive
ENDIF
RETURN ""
ENDFUNC

*----------------------------------------
* FUNCTION CancelConnection(tcDrive)
*----------------------------------------
* Desconecta una unidad de red
* USO: ? CancelConnection("Z:")
*----------------------------------------
FUNCTION CancelConnection(tcDrive)
LOCAL lnRet
DECLARE INTEGER WNetCancelConnection IN WIN32API;
STRING @lpzLocalName, ;
INTEGER nForce
lnRet = WNetCancelConnection( @tcDrive, 0)
IF lnRet # 0
RETURN "Error " + ALLT(STR(lnRet)) + ;
" al desconectar el drive " + tcDrive
ENDIF
RETURN ""
ENDFUNC

*----------------------------------------

Algunos directorios importantes

Muchas veces queremos que nuestras aplicaciones lean o escriban archivos en los directorios que estan por defecto en todas las computadoras que tienen instalado Windows. Por ejemplo el directorio "C:WINDOSW"

La ruta y el nombre de estos directorios, lo podemos conocer con las siguientes funciones de la API de Windows:

• Directorio de Windows................: GetWindowsDirectory
• Directorio System de Windows.....: GetSystemDirectory
• Directorio Temporal de Windows...: GetTempPath

Estas funciones de la API las declaramos directamente en las siguientes funciones definidas por el usuario, para invocarlas facilmente desde Visual FoxPro. Las funciones son las siguientes:

*----------------------------------------
* FUNCTION WinDir()
*----------------------------------------
* Retorna el directorio de Windows
* USO: ? WinDir() -> "C:WINNT"
*----------------------------------------
FUNCTION WinDir()
LOCAL lcPath, lnSize
lcPath = SPACE(255)
lnsize = 255
DECLARE INTEGER GetWindowsDirectory IN Win32API ;
STRING @pszSysPath,;
INTEGER cchSysPath
lnSize = GetWindowsDirectory(@lcPath, lnSize)
IF lnSize <= 0
lcPath = ""
ELSE
lcPath = ADDBS(SUBSTR(lcPath, 1, lnSize))
ENDIF
RETURN lcPath
ENDFUNC

*----------------------------------------
* FUNCTION SystemDir()
*----------------------------------------
* Retorna el directorio SYSTEM de Windows
* USO: ? SystemDir() -> "C:WINNTSYSTEM32"
*----------------------------------------
FUNCTION SystemDir()
LOCAL lcPath, lnSize
lcPath = SPACE(255)
lnsize = 255
DECLARE INTEGER GetSystemDirectory IN Win32API ;
STRING @pszSysPath,;
INTEGER cchSysPath
lnSize = GetSystemDirectory(@lcPath, lnSize)
IF lnSize <= 0
lcPath = ""
ELSE
lcPath = ADDBS(SUBSTR(lcPath, 1, lnSize))
ENDIF
RETURN lcPath
ENDFUNC

*----------------------------------------
* FUNCTION TempDir()
*----------------------------------------
* Retorna la ruta de los archivos temporales
* USO: ? TempDir() -> "C:WINNTTEMP"
*----------------------------------------
FUNCTION TempDir()
LOCAL lcPath, lnRet
lcPath = SPACE(255)
lnSize = 255
DECLARE INTEGER GetTempPath IN WIN32API ;
INTEGER nBufSize, ;
STRING @cPathName
lnRet = GetTempPath(lnSize, @lcPath)
IF lnRet <= 0
lcPath = ""
ELSE
lcPath = ADDBS(SUBSTR(lcPath, 1, lnRet))
ENDIF
RETURN lcPath
ENDFUNC

*----------------------------------------

Nombre de usuario y computadora

Cuando queremos saber el nombre de usuario o el nombre de la computadora, podemos usar directamente desde FoxPro el comando SYS(0), que nos devuelve información sobre el equipo de red cuando se utiliza Visual FoxPro en un entorno de red. Pero también existen las siguientes funciones de la API de Windows que nos devuelven esta información:

• Retorna el nombre del usuario.............: GetUserName
• Retorna el nombre de la computadora...: GetComputerName

Las funciones escritas en código de Visual FoxPro y de fácil uso son las siguientes:

*----------------------------------------
* FUNCTION UserName()
*----------------------------------------
* Retorna el nombre del usuario
* USO: ? UserName() -> "LUISG"
*----------------------------------------
FUNCTION UserName()
LOCAL lcUser, lnSize
lcUser = SPACE(80)
lnSize = 80
DECLARE INTEGER GetUserName IN WIN32API ;
STRING @cUserName, ;
INTEGER @nSize
=GetUserName(@lcUser, @lnSize)
IF lnSize < 2
lcUser = ""
ELSE
lcUser = SUBSTR(lcUser, 1, lnSize-1)
ENDIF
RETURN lcUser
ENDFUNC

*----------------------------------------
* FUNCTION ComputerName()
*----------------------------------------
* Retorna el nombre de la computadora
* USO: ? ComputerName() -> "PC_DESARROLLO"
*----------------------------------------
FUNCTION ComputerName()
LOCAL lcComputer, lnSize
lcComputer = SPACE(80)
lnSize = 80
DECLARE INTEGER GetComputerName IN WIN32API ;
STRING @cComputerName, ;
INTEGER @nSize
=GetComputername(@lcComputer, @lnSize)
IF lnSize < 2
lcComputer = ""
ELSE
lcComputer = SUBSTR(lcComputer, 1, lnSize)
ENDIF
RETURN lcComputer
ENDFUNC

*----------------------------------------

Sonidos y espera

Mediante la API de Windows, podemos ejecutar los sonidos del sistema o cualquier archivo de extensión .wav. También podemos detener la ejecución del programa durante "n" milisegundos. Las funciones son las siguientes:

• Ejecuta el sonido predeterminado del sistema...: MessageBeep
• Ejecuta el sonido de un archivo wav...............: PlaySound
• Detiene la ejecución de un programa...............: Sleep

Para ejecutar estas funciones desde Visual FoxPro usamos lo siguiente:

*----------------------------------------
* FUNCTION Beep(tnSound)
*----------------------------------------
* Ejecuta el sonido predeterminado del sistema
* USO: ? Beep(0)
*----------------------------------------
FUNCTION Beep(tnSound)
tnSound = IIF(VARTYPE(tnSound) = "N", tnSound, 1)
DECLARE INTEGER MessageBeep IN WIN32API ;
INTEGER nSound
RETURN IIF(MessageBeep(tnSound) = 1, .T., .F.)
ENDFUNC

*----------------------------------------
* FUNCTION PlayWav(lcWaveFile, lnPlayType)
*----------------------------------------
* Ejecuta un archivo .WAV
* USO: PlayWave( [,])
* Archivo_Wav = Ruta completa del archivo .Wav
* Ejecucion = 1 - Ejecución en background (default)
* 0 - La aplicación espera la ejecución
* 2 - Si el archivo no existe, no ejecuta el default
* 4 - Apaga el sonido que se está ejecutando
* 8 - Continuado
*----------------------------------------
FUNCTION PlayWav(lcWaveFile, lnPlayType)
lnPlayType = IIF(VARTYPE(lnPlayType) = "N", lnPlayType, 1)
DECLARE INTEGER PlaySound IN WINMM.DLL ;
STRING cWave, ;
INTEGER nModule, ;
INTEGER nType
RETURN IIF(PlaySound(lcWaveFile,0,lnPlayType) = 1, .T., .F.)
ENDFUNC

*----------------------------------------
* FUNCTION Sleep(lnMiliSeg)
*----------------------------------------
* Función que detiene la ejecución de un programa
* durante "n" milisegundos sin interfase con el teclado.
* USO: ? Sleep(1500)
*----------------------------------------
FUNCTION Sleep(lnMiliSeg)
lnMiliSeg = IIF(VARTYPE(lnMiliSeg) = "N", lnMiliSeg, 1000)
DECLARE Sleep IN WIN32API ;
INTEGER nMillisecs
RETURN IIF(Sleep(lnMiliSeg) = 1, .T., .F.)
ENDFUNC

*----------------------------------------

Posición del cursor

Algunas funciones de la API de Windows son muy curiosas, como esta que nos permite configurar la posición del cursor en nuestra pantalla:

• Posiciona el cursor en la pantalla......: SetCursorPos

Esta función en código de Visual FoxPro es:

*----------------------------------------
* FUNCTION SetCurPos(lnX, lnY)
*----------------------------------------
* Coloca el cursor en la posición especificada
* USO: ? SetCurPos(50,200)
*----------------------------------------
FUNCTION SetCurPos(lnX, lnY)
lnX = IIF(EMPTY(lnX),0,lnX)
lnY = IIF(EMPTY(lnY),0,lnY)
DECLARE INTEGER SetCursorPos IN WIN32API ;
INTEGER lnX, ;
INTEGER lnY
RETURN IIF(SetCursorPos(lnX, lnY) = 1, .T., .F.)
ENDFUNC

*----------------------------------------

Verificar si la aplicación está activa

Podemos saber si una aplicación está activa, para ello tenemos la función de la API:

• Busca la ventana activa......: FindWindows

A esta función se le debe pasar como parámetro, el título (caption) de la aplicación. Este parámetro debe ser exactamente igual al título de la ventana de la aplicación que queremos verificar:

*----------------------------------------
* FUNCTION IsActive(tcCaption)
*----------------------------------------
* Verifica si una aplicación ya está activa
* USO: ? IsActive("Calculadora")
*----------------------------------------
FUNCTION IsActive(tcCaption)
DECLARE INTEGER FindWindow IN WIN32API ;
STRING cNULL, ;
STRING cWinName
RETURN FindWindow(0, tcCaption) # 0
ENDFUNC
*----------------------------------------

Con esta función podemos comprobar si nuestra aplicación de Visual FoxPro ya ha sido iniciada en una PC y así no iniciarla nuevamente. Para lograrlo escribiremos una función que se invoca en el inicio de nuestra aplicación, luego de haber colocado el título a nuestra ventana principal.

*----------------------------------------
* FUNCTION YaActiva()
*----------------------------------------
* Comprueba que la aplicación no se esta ejecutando
* Invoca a IsActive() descripta anteriormente
*----------------------------------------
FUNCTION YaActiva()
LOCAL llRet, lcCaption
llRet = .F.
lcCaption = _SCREEN.Caption
*--- Renombra temporariamente el caption de la app
_SCREEN.Caption = "_" + lcCaption
IF IsActive(lcCaption)
*--- Si ya esta activo
MESSAGEBOX("Este sistema ya está activo",16,"Aviso")
llRet = .T.
ENDIF
_SCREEN.Caption = lcCaption
RETURN llRet
ENDFUNC

*----------------------------------------

Si la función YaActiva() retorna .T., entonces ya hay una instancia de la aplicación activa, y debemos cancelar la nueva ejecución.

Mas funciones

Muchas funciones de la API de Windows ya fueron tratadas en este Portal y existen muchas funciones mas, de la que podemos sacar provecho, y darle un toque mas profesional a nuestras aplicaciones.

Los métodos Access y Assign

Métodos Access y Assign

Se ha mejorado Visual FoxPro para que admita los métodos Access y Assign. Estos métodos definidos por el usuario permiten ejecutar código cuando se consulta el valor de una propiedad o cuando se intenta modificar el valor de una propiedad.

El código del método Access se ejecuta cuando se consulta el valor de una propiedad, normalmente con la propiedad en una referencia de objeto, al almacenar el valor de la propiedad en una variable o al mostrar el valor de la propiedad con un signo de interrogación (?).

El código del método Assign se ejecuta cuando se intenta modificar el valor de una propiedad, normalmente mediante los comandos STORE o = para asignar un nuevo valor a la propiedad.

Los métodos Access y Assign sólo se ejecutan cuando se consultan o modifican los valores de las propiedades en tiempo de ejecución. La consulta o modificación de los valores de las propiedades en tiempo de diseño no hace que se ejecuten los métodos Access y Assign.

Nota: Como el valor que intenta asignar a la propiedad se pasa al método Assign, debe incluir una instrucción PARAMETERS o LPARAMETERS en el método Assign para aceptar el valor.

Puede crear independientemente los métodos Access y Assign (puede crear un método Access sin un método Assign o un método Assign sin un método Access).

Puede crear métodos Access y Assign para propiedades creadas mediante programación en una instrucción DEFINE CLASS o de forma interactiva para un formulario o una clase con el Diseñador de formularios y el Diseñador de clases.

Nota: También se pueden crear métodos Access y Assign para todas las propiedades nativas de Visual FoxPro. Por ejemplo, puede crear un método Access para la propiedad Left de un formulario, lo que le permitirá ejecutar código siempre que se consulte la propiedad Left del formulario. Puede crear un método Assign para una propiedad nativa de sólo lectura de Visual FoxPro (por ejemplo, la propiedad ParentClass), pero el método nunca se ejecutará.

Ventajas de los métodos Access y Assign

Los métodos Access y Assign proporcionan las ventajas siguientes:

• Puede crear una interfaz pública para una clase o un objeto que separe la interfaz de la implementación.
• Puede implementar fácilmente la validación de las propiedades.
• Puede proteger fácilmente las propiedades en controles ActiveX que derivan de clases.

Crear métodos Access y Assign

Las mejoras del comando DEFINE CLASS y de los Diseñadores de formularios y de clases le permiten crear métodos Access y Assign mediante programación y de forma interactiva.

Nuevos sufijos para DEFINE CLASS

Se han agregado dos sufijos, _ACCESS y _ASSIGN, al comando DEFINE CLASS para crear métodos Access y Assign. Si anexa una de estas palabras clave al nombre de una función o un procedimiento, se creará un método Access o Assign para una propiedad que tenga el mismo nombre que la función o el procedimiento.

Por ejemplo, el siguiente ejemplo de código utiliza DEFINE CLASS para crear una clase personalizada llamada MiClase. Se crea una propiedad definida por el usuario, MiPropiedad, para la clase. A continuación se crea un método Access para MiPropiedad con la instrucción PROCEDURE.
Cuando se consulta el valor de la propiedad, se ejecuta el código del procedimiento (WAIT WINDOW 'Éste es el método Access'). También se crea un método Assign para MiPropiedad, de nuevo con una instrucción PROCEDURE. Cuando se intente modificar el valor de la propiedad, se ejecutará el código del procedimiento (WAIT WINDOW 'Éste es el método Assign').

Observe el uso de la instrucción LPARAMETERS para aceptar el valor pasado al método Assign. Este ejemplo también muestra cómo puede crear propiedades de sólo lectura.

DEFINE CLASS MiClase AS Custom
   MiPropiedad = 100 && Propiedad definida por el usuario

   PROCEDURE MiPropiedad_ACCESS && Método Access
      WAIT WINDOW 'Éste es el método Access';
          +  ' ' + PROGRAM( )
      RETURN THIS.MiPropiedad
   ENDPROC

   PROCEDURE MiPropiedad_ASSIGN && Método Assign
      LPARAMETERS tAssign  && Necesario para aceptar el valor
      WAIT WINDOW 'Éste es el método Assign';
          + ' ' + PROGRAM( )
   ENDPROC
ENDDEFINE

El ejemplo siguiente muestra cómo puede agregar un método Assign a una propiedad nativa de Visual FoxPro y realizar una sencilla validación del valor de la propiedad que intenta establecer. Observe que en este ejemplo se crea un método Assign sin un método Access correspondiente.

Se usa DEFINE CLASS para crear una clase Form llamada frmMiForm. Se crea un método Assign llamado Left_ASSIGN con una instrucción PROCEDURE. El código del método Assign se ejecuta siempre que se intente asignar un valor a la propiedad Left del formulario.

Si intenta asignar un valor negativo a la propiedad Left, se muestra un mensaje y no se modifica el valor de la propiedad Left. Si intenta asignar un valor no negativo a la propiedad Left, la propiedad Left del formulario queda establecida a dicho valor.

DEFINE CLASS frmMiForm AS Form
   PROCEDURE Left_ASSIGN && Método Assign
      LPARAMETERS tAssign  && Necesario para aceptar el valor
      
      DO CASE
         CASE tAssign < 0 && valor de Left negativo
            WAIT WINDOW 'El valor tiene que ser mayor que 0'
         OTHERWISE  && valor de Left no negativo
            THIS.Left = tAssign
      ENDCASE
   ENDPROC
ENDDEFINE

Los Diseñadores de clases y de formularios
Para crear un método Access o Assign en el Diseñador de formularios

1. Elija Nueva propiedad en el menú Formulario.Se muestra el cuadro de diálogo Nueva propiedad.
   
2. Escriba el nombre de la propiedad que va a crear en el cuadro de texto Nombre y, a continuación, seleccione la casilla de verificación Método Access o la casilla de verificación Método Assign (o ambas).
3. Elija Agregar para crear la propiedad del formulario y para crear los métodos Access y Assign de la propiedad.

Para crear un método Access o Assign para una propiedad intrínseca de Visual FoxPro en el Diseñador de formularios

1. Elija Nuevo método en el menú Formulario.Se muestra el cuadro de diálogo Nuevo método.
2. Escriba el nombre de la propiedad intrínseca seguido de _Access o _Assign en el cuadro de texto Nombre. Por ejemplo, para crear un método Access para la propiedad Left, escriba Left_Access en el cuadro de texto Nombre.
3. Elija Agregar para crear métodos Access o Assign para la propiedad intrínseca.

Nota En el Diseñador de formularios sólo puede crear propiedades con métodos Access y Assign para un formulario o un conjunto de formularios. Para crear propiedades con métodos Access y Assign para un control o un objeto, utilice el Diseñador de clases para crear la clase de control o de objeto. En el Diseñador de clases, agregue propiedades con métodos Access y Assign al control o al objeto y después agregue la clase de control u objeto al formulario en el Diseñador de formularios.

Para crear un método Access o Assign para una clase en el Diseñador de clases

1. Elija Nueva propiedad en el menú Clase.Se muestra el cuadro de diálogo Nueva propiedad.
2. Escriba el nombre de la propiedad que va a crear en el cuadro de texto Nombre y, a continuación, seleccione la casilla de verificación Método Access o la casilla de verificación Método Assign (o ambas).
3. Elija Agregar para crear una propiedad para la clase y crear los métodos Access o Assign de la propiedad.

Método THIS_ACCESS

Se ha agregado a Visual FoxPro 6.0 un nuevo método global de clase, THIS_ACCESS. El código de un método THIS_ACCESS se ejecuta siempre que se intente modificar el valor de un miembro de un objeto o siempre que se intente consultar un miembro de un objeto.

El método THIS_ACCESS se crea en el código en un comando DEFINE CLASS o en los cuadros de diálogo Nuevo método o Modificar propiedades de las bibliotecas de clases visuales .vcx. Un método THIS_ACCESS siempre debe devolver una referencia de objeto; si no es así, se generará un error. Normalmente se devuelve la referencia de objeto THIS. El método THIS_ACCESS también debe incluir un parámetro para aceptar el nombre del miembro del objeto que se modifica o consulta.

El siguiente ejemplo muestra cómo crear un método THIS_ACCESS en el código de un comando DEFINE CLASS. Cuando este ejemplo se ejecuta como programa, 'Caption' se muestra dos veces, la primera cuando se le asigna un valor a la propiedad Caption y la segunda cuando se consulta el valor de la propiedad Caption. Después se muestra el valor de la propiedad Caption ('abc').

CLEAR
oTempObj = CREATEOBJECT('MiForm')  && Crea una instancia del formulario
oTempObj.Caption = 'abc'  && Asigna un valor y desencadena THIS_ACCESS
? oTempObj.Caption  && Consulta un valor y desencadena THIS_ACCESS

DEFINE CLASS MiForm AS Form
   PROCEDURE THIS_ACCESS
      LPARAMETER cMemberName  && Nombre del miembro del objeto

      IF cMemberName = 'caption'
         ? cMemberName  && Muestra el nombre del miembro del objeto
      ENDIF
      RETURN THIS
   ENDPROC
ENDDEFINE

Observe que THIS_ACCESS no pretende ser un sustituto global de los métodos Access y Assign (sólo proporciona información acerca del miembro del objeto al que se tiene acceso o se consulta). A diferencia de los métodos Access y Assign, THIS_ACCESS no proporciona control sobre los valores devueltos a miembros de objeto específicos.

Notas de programación de Access y Assign

Las secciones siguientes describen la información de programación para métodos Access y Assign.

Alcance

Los métodos Access y Assign están protegidos de forma predeterminada (no puede tener acceso a un método Access o Assign ni modificarlo desde fuera de la clase en la que se cree el método Access o Assign).

Incluya la palabra clave HIDDEN cuando cree un método Access o Assign para impedir el acceso y las modificaciones a las propiedades desde fuera de la definición de clase. Sólo los métodos y los eventos de la definición de la clase pueden tener acceso a las propiedades ocultas. Mientras que las subclases de la definición de clase pueden tener acceso a las propiedades protegidas, sólo la definición de la clase puede tener acceso a las propiedades ocultas.

Nota Si no incluye la palabra clave HIDDEN, puede crear subclases con los métodos Access y Assign.

Depuración

Puede ver el código de los métodos Access y Assign en la ventana Seguimiento de la ventana Depurador. Sin embargo, los métodos Access y Assign no se pueden ejecutar en las ventanas Inspección y Locales de la ventana Depurador.

Pasar matrices a los métodos Assign

Se pasan matrices a los métodos Access y Assign de la misma forma en que se pasan a procedimientos estándar de Visual FoxPro.

Si ejecuta SET UDFPARMS TO REFERENCE o se antepone @ al nombre de la matriz, se pasa la matriz completa al método Access o Assign. Si ejecuta SET UDFPARMS TO VALUE o escribe el nombre de la matriz entre paréntesis, se pasa por valor el primer elemento de la matriz. Los elementos de matriz siempre se pasan por valor. Para obtener más información acerca de cómo pasar valores y matrices, vea SET UDFPARMS.

Controles ActiveX

Las propiedades, los eventos o los métodos nativos de los controles ActiveX no admiten las propiedades Access y Assign. Sin embargo, las propiedades, los eventos y los métodos del Contenedor OLE que contiene al control ActiveX sí admite los métodos Access y Assign.

Método ResetToDefault

Si ejecuta el método ResetToDefault para un método Access o Assign se modifica el código del método Access o Assign al miniprograma predeterminado. El resultado es que el código heredado del método, si lo hubiera, no se ejecuta. La técnica utilizada para asegurar que el código heredado de la clase primaria se ejecuta varía según el tipo de método.

Coloque el código siguiente en la subclase de un método Access para ejecutar el código en la clase primaria:

RETURN DODEFAULT( )

Coloque el código siguiente en la subclase de un método Access para ejecutar el código de la clase primaria:

LPARAMETERS vnewval
DODEFAULT(vnewval)
THIS.<propiedad> = vnewval

Coloque el código siguiente en la subclase de un método THIS_ACCESS para ejecutar el código de la clase primaria:

LPARAMETERS cmember 
RETURN DODEFAULT(cmember)

Luis María Guayán