/*
 * $Id: command.txt,v 1.1.1.1 2001/12/21 10:49:28 ronpinkas Exp $
 */

/*
 * Las siguientes partes son derechos adquiridos de sus autores individuales.
 * www - http://www.harbour-project.org
 *
 * Copyright 2000 Alejandro de Grate <alex_degarate@hotmail.com>
 * Documentacin en Espaol de los comandos OOP
 *
 * Copyright 2000 Brian Hays <bhays@abacuslaw.com>
 *    Documentation for the commands
 *
 * Vea doc/license.txt por los trminos de la licencia.
 *
 */


/*  $DOC$
 *  $COMMANDNAME$
 *      CLASS
 *  $CATEGORY$
 *      Comando OOP
 *  $ONELINER$
 *      Define una Clase para la Programacin Orientada a Objetos (OOP).
 *  $SYNTAX$
 *      CLASS <NombreClase> [ <FROM, INHERIT> <SuperClase> ]
 *  $ARGUMENTS$
 *      <NombreClase> Nombre de la clase a definir. Por tradicin, las clases
 *                  en Harbour comienzan con "T" (algo comn en el mundo OOP)
 *                  para evitar colisiones con clases creadas por el usuario.
 *      <SuperClase> La clase padre para usar la herencia.
 *  $DESCRIPTION$
 *      CLASS crea una clase desde la cual se pueden crear objetos.
 *      Cada clase es definida en un archivo.PRG separado para este propsito
 *      No se puede crear ms de una clase en un archivo.PRG
 *      Despus del mandato CLASS comienza la definicin, luego los elementos
 *      DATA (tambien conocidos como variables de instancia) y luego
 *      los METHODS de la clase (el equivalente a las funciones en la
 *      programacin tradicional)
 *
 *      Las Clases pueden heredar desde una clase sola <SuperClass>, pero la
 *      cadena de herencia puede extenderse a muchos niveles
 *
 *      Un program usa una clase llamando al Constructor de la clase, el
 *      mtodo New() para crear el objeto. Ese objeto es usualmente asignado
 *      a una variable, la cual es usada para acceder a los elementos DATA y
 *      a los mtodos
 *  $EXAMPLES$
    <fixed>
 *      CLASS TBColumn
 *
 *         DATA Block      // Codeblock para recuperar datos para la Columna
 *         DATA Cargo      // Variable definida por el usuario
 *         DATA ColorBlock // Codeblock que determina el color de los items
 *         DATA ColSep     // Caracter separador de la Columna
 *         DATA DefColor   // Array de ndices numricos a la tabla de color
 *         DATA Footing    // Pie de Columna
 *         DATA FootSep    // Caracter separador del Pie
 *         DATA Heading    // Encabezado de la Columna
 *         DATA HeadSep    // Caracter separador de la cabecera
 *         DATA Width      // Ancho de la Columna
 *         DATA ColPos     // Posicin temporaria de la columna en pantalla
 *
 *         METHOD New()    // Constructor
 *
 *      ENDCLASS
    </fixed>
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      CLASS es una extensin de Harbour.
 *  $PLATFORMS$
 *      Todas
 *  $SEEALSO$
 *      HBClass(),Programacin Orientada a Objeto,DATA,METHOD
 *  $END$
 */


/*  $DOC$
 *  $COMMANDNAME$
 *      DATA
 *  $CATEGORY$
 *      Comando OOP
 *  $ONELINER$
 *      Define una variable de instance DATA, para los objetos de una clase
 *  $SYNTAX$
 *      DATA <NombreDato1> [,<NombreDatoN>] [ AS <tipo> ] [ INIT <uValor> ]
 *  $ARGUMENTS$
 *      <NombreDato1> Nombre de DATA
 *
 *      <tipo>        Especificacin Opcional del tipo de datos, de uno de
 *                    los siguientes (especificacin en ingls):
 *                    Character, Numeric, Date, Logical, Codeblock, Nil
 *
 *      <uValor>      Valor opcional inicial cuando se crea un nuevo objeto
 *  $DESCRIPTION$
 *      Los elementos DATA tambien pueden ser pensados como "propiedades"
 *        "atributos" de un objeto. ellos pueden ser de cualquier tipo
 *      incluyendo bloques de codigo.
 *      Una vez que el objeto ha sido creado, los elementos DATA son referen-
 *      ciados con dos puntos (:) como en MyObject:Heading := "Nombre".
 *      Usualmente una clase tambin define mtodos para manipular los DATA.
 *
 *      Se puede usar la clausula "AS <type>" para reforzar que DATA es
 *      perteneciente a un cierto tipo. De otra manera este tomar el tipo
 *      de cualquier valor que le sea asignado.
 *
 *      Use la clausula "INIT <uValue>" para inicializar ese DATA a <uValue>
 *      siempre que un nuevo objeto es creado.
 *  $EXAMPLES$
    <fixed>
 *      CLASS TBColumn
 *
 *         DATA Block      // Codeblock para recuperar datos para la Columna
 *         DATA Cargo      // Variable definida por el usuario
 *         DATA ColorBlock // Codeblock que determina el color de los items
 *         DATA ColSep     // Caracter separador de la Columna
 *         DATA DefColor   // Array de ndices numricos a la tabla de color
 *         DATA Footing    // Pie de Columna
 *         DATA FootSep    // Caracter separador del Pie
 *         DATA Heading    // Encabezado de la Columna
 *         DATA HeadSep    // Caracter separador de la cabecera
 *         DATA Width      // Ancho de la Columna
 *         DATA ColPos     // Posicin temporaria de la columna en pantalla
 *
 *         METHOD New()    // Constructor
 *
 *      ENDCLASS
    </fixed>
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      DATA es una extensin de Harbour.
 *  $PLATFORMS$
 *      Todas
 *  $SEEALSO$
 *      Programacin Orientada a Objeto,CLASS,METHOD,CLASSDATA
 *  $END$
 */


/*  $DOC$
 *  $COMMANDNAME$
 *      CLASSDATA
 *  $CATEGORY$
 *      Comando OOP
 *  $ONELINER$
 *      Define una variable CLASSDATA para una clase (NO para un Objeto !)
 *  $SYNTAX$
 *      CLASSDATA <DataName1> [,<DataNameN>] [ AS <type> ] [ INIT <uValue> ]
 *  $ARGUMENTS$
 *      <NombreDato1> Nombre de DATA
 *
 *      <tipo>        Especificacin opcional del tipo de datos de uno de
 *                    los siguientes (Original en ingls):
 *                    Character, Numeric, Date, Logical, Codeblock, Nil
 *
 *      <uValor>      Valor opcional inicial cuando se inicia el programa
 *  $DESCRIPTION$
 *      Las variables CLASSDATA pueden se pensadas como "propiedades" de un
 *      clase entera. Cada CLASSDATA existe slo una vez, no importa cuntos
 *      objetos sean creados. Un uso comun es para un contador que es
 *      incrementado siempre que un objeto es creado y decrementado cuando
 *      alguno es destruido, as se puede monitorear el nmero de objetos en
 *      existencia para esta clase.
 *
 *      Se puede usar la clausula "AS <type>" para reforzar que CLASSDATA es
 *      perteneciente a un cierto tipo. De otra manera este tomar el tipo
 *      de cualquier valor que le sea asignado.
 *      Use la clausula "INIT <uValue>" para inicializar ese DATA a <uValue>
 *      siempre que un nuevo objeto es creado.
 *  $EXAMPLES$
       <fixed>
 *      CLASS TWindow
 *         DATA   hWnd, nOldProc
 *         CLASSDATA lRegistered AS LOGICAL
 *      ENDCLASS
        </fixed>
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      CLASSDATA es una extensin de Harbour.
 *  $PLATFORMS$
 *      Todas
 *  $SEEALSO$
 *      Programacin Orientada a Objeto,CLASS,METHOD,DATA
 *  $END$
 */


/*  $DOC$
 *  $COMMANDNAME$
 *      METHOD
 *  $CATEGORY$
 *      Comando OOP
 *  $ONELINER$
 *      Declara un METHOD (mtodo) para una clase en la cabecera de la clase
 *  $SYNTAX$
 *      METHOD <NombreMtodo>( [<params,...>] ) [ CONSTRUCTOR ]
 *      METHOD <NombreMtodo>( [<params,...>] ) INLINE <Code,...>
 *      METHOD <NombreMtodo>( [<params,...>] ) BLOCK  <CodeBlock>
 *      METHOD <NombreMtodo>( [<params,...>] ) EXTERN <FuncName>([<args,...>])
 *      METHOD <NombreMtodo>( [<params,...>] ) SETGET
 *      METHOD <NombreMtodo>( [<params,...>] ) VIRTUAL
 *      METHOD <NombreMtodo>( [<param>] )      OPERATOR <op>
 *      METHOD <NombreMtodo>( [<params,...>] ) CLASS <ClassName>
 *  $ARGUMENTS$
 *      <NombreMtodo>  Nombre del mtodo a definir
 *
 *      <params,...>    Lista opcional de parametros
 *  $DESCRIPTION$
 *      Los Mtodos son "funciones de clase" y hacen el trabajo de la clase.
 *      Todos los mtodos pueden ser definidos en la cabecera entre los
 *      comandos CLASS y ENDCLASS. Si el cuerpo de un mtodo no esta totalmente
 *      definido aqui, el cuerpo completo es escrito debajo del comando
 *      ENDCLASS usando esta sintaxis:
 *
 *         METHOD <NombreMtodo>( [<params,...>] ) CLASS <NombreClase>
 *
 *      Los Mtodos pueden referenciar al objeto actual usando la palabra
 *      clave "Self:"  su versin ms corta "::"
 *
 *      CLAUSULAS:
 *
 *      CONSTRUCTOR  Define un mtodo especial de la clase: el mtodo
 *                   Constructor, usado para crear objetos. Este es
 *                   usualmente el mtodo New().
 *                   Los constructores siempre retornan el objeto New().
 *
 *      INLINE       Rpido y fcil de codificar, INLINE le permite definir
 *                   el cdigo para el mtodo inmediatamente despus de la
 *                   definicin de la clase. Cualquier mtodo no declarado
 *                   INLINE  BLOCK debe ser completamente definido despus
 *                   del comando ENDCLASS.
 *                   El <Codigo,...> siguiente a INLINE recibe un parametro
 *                   de Self. Si se necesita recibir ms parmetros, use
 *                   la clusula BLOCK en su lugar.
 *
 *      BLOCK        Use esta clusula cuando desee declarar rpidos mtodos
 *                   'inline' que necesiten parmetros. El primer parmetro
 *                    a <CodeBlock> debe ser Self, como en:
 *
 *          METHOD <NombreMtodo> BLOCK {|Self,<arg1>,<arg2>,...,<argN>|...}
 *
 *      EXTERN       Si una funcin externa hace lo que el mtodo necesita,
 *                   use esta clusula para hacer una llamada optimizada a
 *                   esa funcin directamente.
 *
 *      SETGET       Para datos calculados. El nombre del mtodo puede ser
 *                   manipulado como un elemento de DATA para establecer
 *                   (Set) u obtener (Get) un valor.
 *
 *      VIRTUAL      Mtodos que no hacen nada. Utiles para Clases de Base
 *                   donde la Clase hija definir el comportamiento del mtodo,
 *                    cuando Ud. esta creando y probando una Clase.
 *
 *      OPERATOR     Operador de Sobrecarga para las Clases.
 *                   Vea el ejemplo ../Tests/TestOp.prg para detalles
 *
 *      CLASS <ClassName>
 *                   Use esta sintaxis solamente para definir un mtodo
 *                   completo despus del comando ENDCLASS.
 *  $EXAMPLES$
        <fixed>
 *      CLASS TWindow
 *         DATA   hWnd, nOldProc
 *         METHOD New( ) CONSTRUCTOR
 *         METHOD Capture() INLINE  SetCapture( ::hWnd )
 *         METHOD End() BLOCK  { | Self, lEnd | If( lEnd := ::lValid(),;
 *                                 ::PostMsg( WM_CLOSE ),), lEnd }
 *         METHOD EraseBkGnd( hDC )
 *         METHOD cTitle( cNewTitle ) SETGET
 *         METHOD Close() VIRTUAL
 *      ENDCLASS
 *
 *      METHOD New( ) CLASS TWindow
 *         local nVar, cStr
 *         ... <codigo> ...
 *         ... <codigo> ...
 *      RETURN Self
        </fixed>
 *  $TESTS$
        <fixed>
 *      TestOp.prg
         </fixed>
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      METHOD es una extensin de Harbour.
 *  $PLATFORMS$
 *      Todas
 *  $SEEALSO$
 *      HBClass(),Programacin Orientada a Objeto,DATA,CLASS
 *  $END$
 */


/*  $DOC$
 *  $COMMANDNAME$
 *      MESSAGE
 *  $CATEGORY$
 *      Comando OOP
 *  $ONELINER$
 *      Reenva la llamada a un mtodo a otro mtodo.
 *  $SYNTAX$
 *      MESSAGE <NombreMensaje>   METHOD <NombreMtodo>( [<params,...>] )
 *      MESSAGE <NombreMensaje>() METHOD <NombreMtodo>( [<params,...>] )
 *  $ARGUMENTS$
 *      <NombreMensaje>  El nombre del pseudo-mtodo a definir.
 *
 *      <NombreMtodo>   El mtodo a crear y llamar cuando <NombreMensaje>
 *                       es invocado.
 *      <params,...>     Lista de parmetros opcionales para el mtodo
 *  $DESCRIPTION$
 *      El comando MESSAGE es una caracterstica rara vez usada, que permite
 *      re-enviar una llamada a un mtodo con un nombre diferente. Esto puede
 *      ser necesario si el nombre de un mtodo entra en conflicto con una
 *      funcin pblica que necesita ser llamada desde adentro de un mtodo
 *      de la Clase.
 *
 *      Por ejemplo, se puede tener una funcin pblica llamda BeginPaint()
 *      que es usada para pintar las ventanas. Podra ser natural tambin
 *      tener un mtodo de la Clase Ventana, llamado :BeginPaint() que la
 *      aplicacin pueda llamar.
 *      Pero dentro del mtodo de la Clase uno podra no estar habilitado
 *      para llamar a la funcin pblica porque, los mtodos internos estn
 *      basados en funciones estticas (las que ocultan funciones pblicas
 *      con el mismo nombre)
 *
 *      El comando MESSAGE permite crear el verdadero mtodo con un nombre
 *      diferente (::xBeginPaint()), y an permitir la sintaxis ::BeginPaint()
 *      para llamar a ::xBeginPaint(). Este entonces es libre de llamar a
 *      a la funcin publica BeginPaint().
 *  $EXAMPLES$
    <fixed>
 *      CLASS TWindow
 *         DATA   hWnd, nOldProc
 *         METHOD New( )  CONSTRUCTOR
 *         MESSAGE BeginPaint METHOD xBeginPaint()
 *      ENDCLASS
    </fixed>
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      MESSAGE es una extensin de Harbour.
 *  $PLATFORMS$
 *      Todas
 *  $SEEALSO$
 *      METHOD,DATA,CLASS,Programacin Orientada a Objeto
 *  $END$
 */


/*  $DOC$
 *  $COMMANDNAME$
 *      ERROR HANDLER
 *  $CATEGORY$
 *      Comando OOP
 *  $ONELINER$
 *      Designa un mtodo como manejador de error para la Clase.
 *  $SYNTAX$
 *      ERROR HANDLER <NombreMtodo>( [<params,...>] )
 *  $ARGUMENTS$
 *      <NombreMtodo>  Nombre del mtodo a definir
 *
 *      <params,...>    Lista de parametros opcionales
 *  $DESCRIPTION$
 *      ERROR HANDLER nombra al mtodo que deberia manejar los errores para
 *      la Clase que esta siendo definida.
 *  $EXAMPLES$
    <fixed>
 *      CLASS TWindow
 *         ERROR HANDLER  MyErrHandler()
 *      ENDCLASS
    </fixed>
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      ERROR HANDLER es una extensin de Harbour.
 *  $PLATFORMS$
 *      Todas
 *  $SEEALSO$
 *      Object Oriented Programming,ON ERROR,CLASS,METHOD,DATA
 *  $END$
 */


/*  $DOC$
 *  $COMMANDNAME$
 *      ON ERROR
 *  $CATEGORY$
 *      Comando OOP
 *  $ONELINER$
 *      Designa un mtodo como manejador de error para la Clase.
 *  $SYNTAX$
 *      ON ERROR <NombreMtodo>( [<params,...>] )
 *  $ARGUMENTS$
 *      <NombreMtodo>  Nombre del mtodo a definir
 *
 *      <params,...>    Lista de parametros opcionales
 *  $DESCRIPTION$
 *      ON ERROR es un sinnimo para ERROR HANDLER.
 *      Este nombra al mtodo que debera manejar los errores para la
 *      Clase que esta siendo definida.
 *  $EXAMPLES$
    <fixed>
 *      CLASS TWindow
 *         ON ERROR  MyErrHandler()
 *      ENDCLASS
    </fixed>
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      ON ERROR es una extensin de Harbour.
 *  $PLATFORMS$
 *      Todas
 *  $SEEALSO$
 *      Programacin Orientada a Objeto,ERROR HANDLER,CLASS,METHOD,DATA
 *  $END$
 */


/*  $DOC$
 *  $COMMANDNAME$
 *      ENDCLASS
 *  $CATEGORY$
 *      Comando OOP
 *  $ONELINER$
 *      Termina la declaracin de una Clase.
 *  $SYNTAX$
 *      ENDCLASS
 *  $DESCRIPTION$
 *      ENDCLASS marca el fin de la declaracin de una Clase.
 *      Este es usualmente seguido por el mtodo de la Clase que no es INLINE.
 *  $EXAMPLES$
     <fixed>
 *      CLASS TWindow
 *         DATA   hWnd, nOldProc
 *      ENDCLASS
     </fixed>
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      ON ERROR es una extensin de Harbour.
 *  $PLATFORMS$
 *      Todas
 *  $SEEALSO$
 *      Programacin Orientada a Objeto,CLASS,METHOD,DATA
 *  $END$
 */
