Bueno, para ir ampliando esta seccion voy a poner un tutorial de lo que es uno de mis lenguajes preferidos, Gambas

Gambas es un intérprete de VisualBasic para Linux, muy sencillo de aprender y utilizar, y para empezar a hacer interfaces sencillas es el mejor lenguaje que se me ocurre, y aunque no tengas linux es una buena base para seguir metiendote dentro del mundillo de VisualBasic (que ya pondré un tutorial de eso otro dia)



Tabla de contenidos:

1. Instalando Gambas
2. Hola Mundo 1
3. Hola Mundo 2
4. Hola Mundo 3
5. Algo de Teoría Basica
6. Evento KeyPress
7. Grupos de Controles
8. Trabajo con Eventos
9. Multiidioma
10. Proceso de Traducción

1.Instalando Gambas


Distribuciones

En la página oficial de Gambas, puedes encontrar tanto el código fuente, como indicaciones para encontrar paquetes binarios de este software: http://gambas.sourceforge.net notas importantes:

TODAS LAS DISTRIBUCIONES: Los paquetes binarios no tienen por qué corresponder siempre a la última versión disponible, algunas distribuciones pueden tener paquetes especialmente anticuados, con versiones anteriores a la 1.0. En esos casos, es mejor bajar el código fuente y compilarlo en la propia máquina.

DEBIAN: desde los repositorios de Linex, puedes encontrar los paquetes más actualizados disponibles.


Componentes

Para instalar la mayor parte de los componentes de Gambas, es necesario instalar una serie de librerías en el sistema, de las cuales los componentes se sirven para realizar su labor:

gb.net : depende tan sólo de la librería estándar de C, glibc, por lo que disponiendo de un sistema Linux o *BSD en marcha, no se necesita nada adicional.




gb.net.curl : emplea libcurl para su trabajo. La librería se puede encontrar como código fuente desde su web http://curl.haxx.se/ . Compilándola e instalándola antes de instalar Gambas, este componente funcionará correctamente. Hay que tener en cuenta que Gambas necesita como mínimo la versión 7.11 de libcurl. Con versiones anteriores, el componente gb.net.curl no funcionará correctamente, o ni siquiera compilará. También es posible instalar libcurl con los binarios de sistemas Mandrake o RedHat/Fedora modernos mediante la herramienta "urpmi" ( ejecutar urpmi libcurl y urpmi libcurl-devel debería bastar), y en sistemas Debian,Linex o Ubuntu (usando apt-get install libcurl y apt-get install libcurl-devel o bien con la herramienta gráfica Synaptic). En caso de instalar binarios, es necesario, como se indicó previamente, que los paquetes instalados correspondan a la versión 7.11 o posterior

2. Hola Mundo 1

1. Vamos a seguir una serie de pasos, sin pensar demasiado, para hacer una aplicación muy sencilla, esto nos servirá para familiarizarnos con Gambas, aunque aún desconozcamos muchas cosas.
2. Ejecuta Gambas, pulsa la opción "Nuevo Proyecto", aparecerá el asistente de creación de nuevos proyectos, lee la información, y pulsa "siguiente". Elige la opción "Crear un proyecto gráfico", y pulsa "siguiente". En nombre de proyecto pon "HolaMundo", por ejemplo, y en el título, "Proyecto de pruebas".
   
   
3. Elige la carpeta a partir de la cual se creará la carpeta donde se almacenarán los archivos del proyecto. Si la creas, por ejemplo, en "/home/usuario", se creará una carpeta "/home/usuario/HolaMundo". Pulsa "siguiente". Lee la información, y pulsa OK.
4. Aparecerá el entorno de desarrollo. Por ahora no hemos creado nada, verás que en el árbol del proyecto (que aparece con la cabeza de la mascota, y el nombre "HolaMundo"), hay una serie de secciones para depositar las diferentes partes del proyecto. De momento no te preocupes por todas las opciones.
   
   
5. Pulsa "Formularios" con el botón izquierdo para seleccionar esta sección, y a continuación pulsa el botón derecho para que aparezca un menú flotante. Si eres zurdo y has configurado el ratón de ese modo, los botones serán los contrarios, derecho para seleccionar, e izquierdo para los menús.
6. En el menú aparece la opción "Nuevo". Sitúate sobre ella, y en el nuevo menú que surge, pulsa sobre la opción "formulario", con el botón izquierdo.
   
   
7. Aparece un pequeño asistente para formularios. En "nombre" puedes poner "FrmPrincipal", para identificarlo. Deja el resto de las opciones por defecto, y pulsa "OK".
8. Podrás comprobar que ha aparecido un formulario vacío, listo para editar. Si te situas en el borde del formulario, hasta que el cursor cambie de forma, y lo mueves mientras mantienes el botón izquierdo pulsado, comprobarás que puedes variar el tamaño del formulario hasta darle la forma que deseas.
   
   
9. Ahora fíjate en la "Caja de herramientas". Aquí se muestran los controles que podemos utilizar para diseñar los elementos de nuestro formulario. De momento utilizaremos una etiqueta. Pulsa con el botón izquierdo en el icono que tiene una letra "A" grande y a continuación sitúate con el ratón en el formulario, y, mientras mantienes pulsado el botón izquierdo, mueve el ratón hacia la derecha y hacia abajo. Verás como la etiqueta se situa sobre el formulario y puedes variar su tamaño. Si sueltas el botón del ratón y acontinuación pulsas sobre la etiqueta, verás que aparecen en los extremos unos cuadritos. Si te situas sobre ellos, mantienes el botón izquierdo pulsado, y mueves el ratón, puedes variar el tamaño de la etiqueta, y en general, de cualquier control que uses. Si te situas en el centro de la etiqueta, y mantienes pulsado el botón izquierdo mientras mueves el ratón, cambiarás la posición de la etiqueta en el formulario.
   
   
10. Vamos a dar el toque final, pulsa la etiqueta y mira la ventana de propiedades, aquí vemos las características de la etiqueta. Busca la propiedad llamada "Text", y escribe ahí "Hola Mundo". Para que quede más bonito, busca la propiedad "Align", y selecciona "Center".
    
    
11. Y por último, la magia, ve al menú "Proyecto" de la ventana principal de Gambas, y pulsa en la opción "Ejecutar". ¡Ahí lo tienes! tu programa con una ventana diciendo "¡Hola Mundo!"
    
    
12. Ha sido fácil, ¿verdad?. No ha sido necesario emplear ni una línea de código, sólo trabajar con el ratón un poco.

3. Hola Mundo 2

Ahora vamos a aplicar un poco de código escrito para hacer un ejemplo más vivo. ¿Has leído el tutorial anterior del "Hola Mundo"? Pues si no lo has hecho, aprovecha ahora, y realiza los pasos indicados en él del número 1 al número 7, de forma que tengas un formulario vacío listo para editar.


1. Vamos a añadir un botón. Mira ahora en la "Caja de herramientas". Hay un control que parece un botón con el texto "OK". De hecho, es un botón.
   
   
2. Sitúalo en el formulario del mismo modo que hiciste con la etiqueta del primer programa, de modo que quede situado a tu gusto. A continuación busca en la ventana de propiedades la propiedad "Text", y cambia su valor por "Saludar".
   
   
3. Ahora pulsa dos veces seguidas (o doble click, como le gusta decir a muchos) sobre el botón. Accederás a una ventana de código, en el que te indica esto:
   
   ' Gambas class file
   
   PUBLIC SUB Button1_Click()
   
   
   
   END
   
4. Vamos a pararnos un momento a ver este código: observa la primera línea, verás que comienza con el símbolo " ' ". Todas las líneas que empiezan por este símbolo, son "comentarios", y significa simplemente que es una nota aclaratoria para el programador, que es ignorada totalmente por el compilador de Gambas. Si quieres, prueba a añadir más comentarios en el código:
   
   ' Gambas class file
   ' Este es un ejemplo de programa sencillo
   ' para aprender algunos conceptos
   ' básicos sobre Gambas
   
   PUBLIC SUB Button1_Click()
   
   
   
   END
   
5. Observemos las siguientes líneas: "PUBLIC SUB Button1_Click()" y "END". Estas dos palabras claves definen el principio y final de una "Función". Una función no es más que un conjunto de ordenes que Gambas ejecuta cuando la función es llamada. En este caso, la función se ejecutará cuando se haga "Click" sobre el botón "Button1". Ahora mismo no hay nada entre el principio y el final de la función, por tanto no pasará nada al pulsar el botón.
6. Diremos a Gambas que ha de mostrar un diálogo de mensaje diciendo "Hola Mundo" cuando se pulse el botón. Para eso, utilizaremos el objeto "Message". Ya hablaremos más adelante acerca de los objetos:
   
   ' Gambas class file
   ' Este es un ejemplo de programa sencillo
   ' para aprender algunos conceptos
   ' básicos sobre Gambas
   
   PUBLIC SUB Button1_Click()
   
   Message.Info ("¡Hola Mundo!")
   
   END
   
7. Después de escribir "Message." habrás observado que se ha desplegado un menú con varias palabras clave: "Info", "Warning", ... Esto es lo que se llama "autocompletado de código", y es una utilidad para mostrarte las diferentes posibilidades que ofrece un objeto, en este caso "Message". Cuando termines este ejemplo, prueba las otras opciones, verás como varía el aspecto del mensaje. También habrás comprobado que tras escribir el paréntesis inicial, aparece una ayuda indicando la sintáxis de este método.
   
8. Ahora ya solo resta probarlo. Si has hecho todo bien, tras acudir al menú "Proyecto", y pulsar la opción "ejecutar", aparecerá el formulario con nuestro botón. Pulsa el botón, y surgirá el mensaje deseado.
   

4. Hola Mundo 3

Ahora vamos a trabajar sin utilizar el componente gráfico. Hay muchos programas que no necesitan de componente gráfico, por ejemplo, por que sólo realizan tareas no visibles para el usuario, o porque quieren consumir pocos recursos, o porque el equipo donde se ejecutará no va a disponer de sistema gráfico. Hay múltiples razones para utilizar sólo la consola, y los ejemplos indicados son sólo unas pocas.
1. Ejecuta Gambas, y selecciona nuevo proyecto. Al llegar hasta el punto donde se selecciona el tipo de proyecto, elige "Crear un proyecto de terminal"
   
   
2. El resto de los pasos ya los sabes desde el primer tutorial. Una vez estás en la interfaz de Gambas, tendremos que escribir el código para escribir "Hola Mundo" en la consola (o terminal, la palabra que más te guste). Ya no podemos crear un nuevo formulario, puesto que no hay interfaz gráfica. Crearemos entonces un nuevo módulo, que es un archivo de código que no está asociado a ningún formulario. También podríamos haber creado una clase, pero como no sabemos todavía nada de clases y objetos, lo dejaremos para más adelante. Pon al módulo el nombre "ModPrincipal", y acepta.
   
   
3. Observa que en el código ha aparecido una función, automáticamente, como ocurrió en la segunda parte de este tutorial.
   
   ' Gambas module file
   
   PUBLIC SUB Main()
   
   END
   
4. Todos los programas cuyo inicio no se encuentra en un formulario, deben tener una función, llamada forzosamente "Main", que será la que se ejecute nada más comenzar el programa. Ahora mismo no hay nada, y si ejecutáramos el programa, nada pasaría. De hecho, este es el programa más simple que puede escribirse con Gambas. Añadiremos ahora el código para mostrar nuestro mensaje. Ya no utilizaremos la clase "Message", que forma parte del componente gráfico de Gambas, si no una función llamada "PRINT" que permite "imprimir" mensajes en la consola:
   
   ' Gambas module file
   
   PUBLIC SUB Main()
   
   PRINT "Hola Mundo"
   
   END
   
5. Para ver mejor el resultado del programa, vamos a aprender a compilar un programa. Acude al menú "Proyecto" y pulsa la opción "Crear Ejecutable". Si no te aparece ningún mensaje de error, ya tienes el ejecutable listo para utilizar. ¿Dónde está, por cierto? Pues está en la carpeta del proyecto, así si el proyecto se encuentra, por ejemplo en /home/usuario/HolaMundo, el ejecutable estará dentro de esta carpeta, y con el nombre "HolaMundo".
   
6. Abre una ventana de terminal, acude a la carpeta, y ejecuta el programa para ver el resultado.
   
   
   
   
   Es el momento de decir también que hay dos tipos de lenguaje de programación, los compilados y los interpretados. Los primeros, al compilar, crean verdaderos binarios, código entendible directamente por el microprocesador del equipo. Los segundos, o bien no disponen de compilador (como la shell bash), o bien el compilador genera un "código intermedio", como es el caso de Java o Gambas. Dicho código intermedio, no es entendible directamente por el microprocesador, si no que un programa llamado intérprete (gbx, en el caso de Gambas), hace de intermediario entre la ejecución real del programa y el código intermedio. La razón de utilizar ese código intermedio, es que es más rápido que el código "humano" que nosotros hemos escrito, aunque más lento que el código binario.
   Este planteamiento tiene la ventaja de que el código generado puede ser ejecutado en cualquier máquina para la que exista un intérprete del lenguaje, independientemente de la marca del procesador o el sistema operativo (compila una vez y úsalo en todos sitios, es el lema). Como inconveniente, el rendimiento es menor (no se puede utilizar para aplicaciones que exijan gran rendimiento del equipo), y es necesario tener instalado el intérprete en la máquina.

5. Algo de Teoría Basica


Existen muchas teorías programación, Gambas implementa algunos de sus conceptos, y vamos a tratar de aclararnos un poco respecto a las técnicas en las que nos apoyaremos para programar.

Programación estructurada

La verdad es que el título es algo pretencioso, hay libros completos sobre ello, pero lo que aquí interesa explicar es el concepto de "variable", "función" y "ámbito".

Variables:

Los programas almacenan la información de uso inmediato en memoria RAM. Trabajando al más bajo nivel, se deposita la información indicando la dirección de la memoria RAM directamente. Esto es muy engorroso, especialmente cuando el número de datos a almacenar es muy grande.


Para solucionarlo, los lenguajes de programación aportan el concepto de "variable": es nombre al cual nos referimos para almacenar información u obtenerla, de direcciones de memoria que se gestionan sin que a nosotros nos afecte directamente.


Nosotros indicaremos un nombre, por ejemplo "MiValor", asignaremos valores con el operador " = " (MiValor = 3), y haciendo referencia a ese nombre podremos leer su contenido (PRINT MyValor , mostraría en pantalla "3" en este ejemplo).


Según el lenguaje de programación se habla de que no está "tipado", o que está "tipado", en función del modo en que usa las variables. En un lenguaje "no tipado", cada variable puede almacenar cualquier cosa, (un número, una cadena de texto, etc). Esto puede estar bien para programar muy rápido, pero da lugar a graves errores en aplicaciones medianas y grandes. Gambas, por el contrario, es un lenguaje "tipado", y esto significa que de modo previo al uso de cualquier variable, forzosamente hemos de "declararla", especificando el tipo de datos que va a contener. Estos son algunos ejemplos de "declaraciones" con Gambas:

DIM MyVar As Integer PRIVATE Respuesta As String PUBLIC Suma As Float


En estos ejemplos, y sin que nos interese ahora la primera parte de estas declaraciones (DIM, PRIVATE,PUBLIC), estamos indicando que deseamos utilizar una variable llamada "MyVar" que almacenará números enteros, otra llamada "Respuesta" que almacenará cadenas de texto, y otra llamada "Suma" que almacenará números con coma flotante (es decir, es capaz de almacenar números con parte decimal)

Funciones:

En los primeros tiempos de la informática, y en realidad, en la actualidad los microprocesadores siguen trabajando así, los programas eran una ristra larguísima de ordenes, una detrás de otra, sin más posibilidad de "estructuración" que dar saltos hacia a delante o hacia atrás en el código.


Más adelante se impuso un modelo más "estructurado": dividir el código en bloques separados, llamados "funciones" o "métodos". Un programa completo estará formado por funciones, pequeños bloques de código a los que se le envían una serie de valores de los cuales se hace responsable para procesarlos, y retornar un valor, si procede.


Cada programa en Gambas empieza con una función "Main", o principal, y a lo largo de su código, esta función envía datos a otras funciones, y , si es necesario, recibe sus resultados. Este proceso se denomina "llamada", una función "llama" a otra función, esta puede "llamar" a otras, etc. Los valores que se envían para ser procesados, se denominan "parámetros".


Para indicar a Gambas el inicio de una función, emplearemos básicamente esta nomenclatura:




PUBLIC FUNCTION nombre_de_la_funcion (p1 As TipoDato,p2 As TipoDato...) As TipoDato o bien PUBLIC SUB nombre_de_la_funcion (p1 As TipoDato,p2 As TipoDato...)


Respecto a la palabra "PUBLIC", no nos preocuparemos por ahora, pero observa que podemos indicar "FUNCTION" o "SUB". La primera palabra significa que el código de la función va a retornar algún valor, mientras que "SUB" significa que se trata de una función que no retornará ningun valor, como fue el ejemplo de nuestro segundo tutorial∞, donde emitíamos un mensaje, pero no retornabamos ningún valor.


nombre_de_funcion : Es el nombre con que llamaremos a la función desde otras partes del código, y será un identificador único para ese fragmento de código en todo el programa.


(p1 As TipoDato,p2 As TipoDato...) : A continuación, se indican las variables que se pasarán como parámetros, separadas por comas, e indicando el tipo de la variable, del mismo modo que en las declaraciones antes explicadas. Según lo que vaya a hacer la función emplearemos más o menos parámetros.


As TipoDato : Si hemos indicado la palabra clave "FUNCTION", indicaremos al final el tipo de dato que vamos a devolver. Dependiendo del tipo de parámetros que utilicemos, estos pueden tambien utilizarse en ocasiones para devolver el resultado deseado, al margen de este valor retornado.


Unos ejemplos:




Una función que no devuelve ningún valor y no necesita parámetros: PUBLIC SUB MyFuncion() Una función que no devuelve ningún valor y necesita un valor entero como parámetro: PUBLIC SUB OtraFuncion(MiValor As Integer) Una función que devuelve una cadena de texto y necesita un valor entero y un valor de cadena: PUBLIC FUNCTION OtraMas(MiDato As Integer,MiCadena As String) As String

Ámbito

No todas las funciones y variables se utilizan desde todo el código, hay varias razones para limitar las zonas desde donde se puede acceder a una variable o función: desde razones de rendimiento, por ejemplo, es mejor tener variables que se creen y se destruyan tras ser usadas, que tener un "monstruo" en memoria con todas las variables permanentemente almacenadas, hasta razones de comodidad para el programador, ya que es mejor poder definir el mismo nombre para ciertas variables, en zonas "aisladas" del código, que tener que inventar miles de nombres a lo largo de un gran programa.


Gambas permite verias técnicas para separar o aislar el "ámbito" de las variables y funciones. Los programas escritos en Gambas, constan de "módulos", "formularios", y "clases". Pues bien, el código de cada módulo está parcialmente aislado del código de todos los demás, y de igual modo sucede con los formularios y clases. Es posible tener dos módulos que contengan una función con el mismo nombre:




Módulo 1: Public SUB MiFuncion(Dato As Integer) Módulo 2: Public SUB MiFuncion(Dato As Integer)


Si nos encontramos dentro de otra función del módulo 1, yqueremos llamar a la función "MiFuncion", directamente lo indicaremos así en el código:




... MiFuncion(34) ...


Al llamar a "MiFuncion", el intérprete sabe que nos referimos a la función que se encuentra dentro del mismo módulo. Ahora bien, si nos encontramos dentro del módulo 2, o de cualquier otro módulo, clase o formulario, hemos de especificar el módulo en el que se encuentra la función. Así, si desde el módulo 2 indicaramos:




... Mifuncion(9654) ...


Realmente estaríamos llamando a la función con ese nombre que se encuentra dentro del módulo 2. Hemos de especificar que deseamos utilizar la del módulo 1, indicando el nombre del módulo, un punto, y el nombre de la función:




Modulo1.MiFuncion(9654)


La segunda técnica para delimitar el ámbito de la función, es indicar al intérprete si deseamos que esa función sea accesible desde otro módulo, formulario o clase. Si indicamos la palabra "PUBLIC", delante de la declaración de la función, esta podrá ser llamada desde otros módulos, clases o formularios, pero si indicamos "PRIVATE", sólo podremos acceder desde el propio módulo (se dice también que "no es visible" desde otros módulos)


En cuanto a las variables, tenemos los mismos casos que con las funciones, y otro más:


Las variables pueden ser declaradas al principio del módulo, formulario o clase, antes de cualquier función, en este caso emplearemos las palabras "PRIVATE" y "PUBLIC" de igual modo que con las funciones, y estas variables existirán mientras exista el módulo, clase o formulario. Pero también podemos indicar una variable dentro de una función, empleando ahora la palabra clave "DIM", y en este caso la variable sólo existe desde que se entra en la función, hasta que se sale, y no es accesible en absoluto desde ninguna otra zona del código fuera de la función.




PRIVATE Var1 As Integer PUBLIC Var2 As String PUBLIC FUNCTION SumaEspecial (V1 As Integer,V2 As Integer) As Integer DIM Media As Integer Media=(V1+V2)/2 RETURN Media+V1+V2 END

Pues a lo mejor me animo y hago cualquier chorrada xDD

P.D: Anda que yo, pensar que cuando decias: (copy paste del MSN xD)

<-._.-Choms-._.-> http://board.botmania.net | 64 Bits, 64 Threads - OpenSPARC dice:
anda y mirate el tuto de gambas

[P^3] Fraude At times, I think like Emo... =( dice:
gambas?
<-._.-Choms-._.-> http://board.botmania.net | 64 Bits, 64 Threads - OpenSPARC dice:
si, gambas

[P^3] Fraude At times, I think like Emo... =( dice:
en la vida praactica, que usos le puedo dar a gambas (a parte de alimentarme claro xDD)

------------------------

Para quien no lo sepa, gambas, se puede usar entre otras cosas para:

puedes crear formularios, botones de comandos, cuadros de texto o enlazar bases de datos como MySQL, PostgreSQL o SQLite -------- Segun se, es como Visual Basic xDD

Salu2!

P.D: Perdon por el tocho post

Se ve que no se puede instalar en AMD64 porque una de sus librerias (gambas2-gb-compress-gzip, pero no estoy muy seguro) no da soporte a la arquitectura.

Me tendré que aguantar.

Se agradecerían sugerencias. Gracias.

Un saludo, a2.

Yo creo que si se puede poner... o si no pon el de la arquitectura x86 que tambien es compatible con los AMD de 64 bits (yo uso un atholon, o como se escriba, de 32 bits y Gambas me funciona) de todas maneras intentalo que tampoco pasa nada por probar. Yo tampoco le hago mucho caso a lo de las arquitecturas porque si no no instalaria nada en el portatil xD

Salu2

Bueno, continuando con el tutorial...

6. Evento KeyPress


Con Gambas se puede utilizar la clase 'Key' para conocer las teclas que pulsa el usuario sobre cualquier control gráfico. Cada control, posee dos eventos para indicarnos la acción del usuario:




KeyPress : se activa cuando el usuario aprieta la tecla
KeyRelease : se activa cuando el usuario suelta la tecla


Estos eventos no disponen de parámetros, ya que la clase 'Key' almacena en cada momento el código de la tecla que se acaba de apretar o soltar. Es una clase estática, por la tanto no es necesario que creemos ningún objeto de esa clase para utilizarlo:

... PUBLIC SUB Button1_KeyPress() Message.Info(Key.Code) END ...


Cuando se pulse una tecla con el foco situado sobre el botón, se mostrará un mensaje con el código de la tecla pulsada. Si pulsa por ejemplo la flecha derecha, devolverá el valor 4116. Con ello ya se sabe que ese código corresponde a la flecha derecha. Si se desea que el evento responda sólo a la pulsación de una/s determinada/s teclas:

... PUBLIC SUB Button1_KeyPress() IF Key.Code = 4116 THEN Message("Has pulsado la tecla de flecha derecha") END IF END ...


También podemos valernos de las constantes que aporta la clase "Key" para olvidarnos de los extraños códigos numéricos de cada tecla:

... PUBLIC SUB Button1_KeyRelease() IF Key.Code = Key.Right THEN Message("Has soltado la tecla de flecha derecha") END IF END ...


Por último, el evento KeyPress es cancelable, de modo que podemos evitar que la pulsación de una tecla llegue al programa, para cancelar, por ejemplo, una acción del usuario no admitida en ese momento:

... PUBLIC SUB Button1_KeyPress() IF key.Code <> key.Tab THEN STOP EVENT END ...


Se observa en el ejemplo, que se evita la cancelación del evento cuando la tecla "Tab" es pulsada, dada la importancia de esta tecla para moverse por los formularios sin necesidad del ratón.


La clase "Key" aporta también los valores 'Alt', 'Code', 'Control'y 'Shift' para saber si estas teclas estaban pulsadas a la vez que la principal.

7. Grupos de Controles


En otros lenguajes de programación, como VB, se suele trabajar con grupos de controles, de forma que, por ejemplo, varios botones lancen un evento común al ser pulsados, y dentro del evento, cada botón se distingue, en el caso de VB, con el valor "Index" que aporta el evento.


Gambas tiene su propia solución:


1) En tiempo de diseño: Dentro del IDE, en el panel de propiedades de un objeto gráfico, existe siempre una propiedad llamada "Group", que no es en sí una propiedad real de dicho objeto, si no el nombre que se dará a su gestor de eventos.
Por defecto, cuando no se indica nada, el gestor de eventos se llama igual que el objeto, así, si tenemos un botón llamado "Btn1", su gestor de eventos será "Btn1", de forma que para capturar un evento, como puede ser "Click", escribiremos el código así:PUBLIC SUB Btn1_Click() ... END Sin embargo, si especificamos la pseudo-propiedad "Group", podremos indicar cualquier otro nombre, y de hecho podemos indicar el mismo nombre para múltiples controles. Si disponemos, por ejemplo, de cinco botones, y a los cinco les ponemos "Botones" como valor de "Group", capturaremos los eventos de los cinco dentro de:PUBLIC SUB Botones_Click() ... END ¿Y cómo sabemos cual es el botón pulsado? Dentro de cada evento, se puede llamar a un objeto especial, llamado "LAST", el cual mantiene una referencia al objeto que lanzó el evento. Así, si indicamos PRINT LAST.Text Se mostrará en la consola el texto del botón que ha lanzado el evento. También podemos emplear la propiedad "TAG" de cada botón para añadir cualquier característica específica que requiramos para diferenciarlos:SELECT CASE LAST.Tag ... ... END SELECT




2) En tiempo de ejecución: en Gambas tenemos libertad para crear cualquier control durante la ejecución de un programa. Si deseamos crear seis botones, y hacer que respondan a un gestor de eventos común, lo indicaremos en la creación del control:DIM Btn As Button ... Btn=NEW Button(ME) AS "Botones" ... De esta forma, todos los botones creados responden al gestor de eventos "Botones", y podemos, como se hizo en el primer caso, diferenciarlos por la palabra clave "LAST".
También tenemos la posibilidad de almacenar una referencia a cada botón dentro de una matriz tipo "Object[]" para manejarlos desde fuera de los eventos.

8. Trabajo con Eventos


La interfaz gráfica ofrece una serie de eventos para modelar el comportamiento de un programa, no obstante, podemos crear nuestros propios eventos personalizados, y no sólo en programas gráficos, si no también en programas de consola, ya que la gestión de eventos de Gambas es independiente del entorno gráfico, a diferencia de otros lenguajes.


Para empezar, crearemos un módulo de clase llamado, en nuestro ejemplo, "ClsElemento". Esta clase de ejemplo, tendrá un sólo método "Llamada()" que incrementa un contador. Una vez que el contador alcanza el valor "10", se resetea el contador, y se dispara un evento para informar de ello.


Lo primero es declarar el evento. En nuestro caso, enviará como parámerto una cadena advirtiendo que el contador vale 10:


EVENT MiEvento(Data AS String)


Tras esto, añadimos una variable privada que actúa como contador:


PRIVATE Contador AS Integer


Escribimos ahora el código de la función de llamada:


PUBLIC SUB Llamada() ' Incrementamos el contador Contador=Contador+1 IF Contador>9 THEN ' Si el valor del contador es 10 ' disparamos el evento RAISE MiEvento("Contador vale 10") ' Y reseteamos el contador Contador=0 END IF END


Finalmente, escribimos el código principal del programa. Para ello cremos un formulario con un botón. Al inicio declaramos un objeto de nuestra clase:


PRIVATE MiClase AS ClsElemento


Al abrirse el formulario, creamos el objeto, declarando el "observador" de eventos entre comillas:


PUBLIC SUB Form_Open() MiClase=NEW ClsElemento AS "MiObservador" END


Añadimos al botón el código para que utilize el objeto:


PUBLIC SUB Button1_Click() MiClase.Llamada () END


Y finalmente, recogemos el evento:


PUBLIC SUB MiObservador_MiEvento(Data AS String) Message.Info (Data) END


Esta función tiene el nombre del "observador" de eventos, un guión bajo, y el nombre del evento, por lo que será llamada cuando se dispare el evento.

9. Multiidioma


Gambas incorpora soporte nativo para crear aplicaciones que se distribuyan entre usuarios que hablan idiomas distintos. Un proyecto ha de ser marcado como "Traducible" para que esto sea posible.

1. En una nueva aplicación
Crea un nuevo proyecto gráfico con Gambas y detente en el punto donde se solicita el nombre del proyecto. Observarás que puedes marcar un "check" que indica que el proyecto es traducible. Márcala.


El proyecto gestionará de forma automática los textos a partir de ese momento.

2. En una aplicación ya existente
Acude al menú "Proyecto" y dentro de este pulsa "Propiedades".

En el asistente de propiedades del proyecto, acude a la pestaña "Traducción" y marca la opción "El proyecto es traducible". Acepta los cambios.


3. Trabajo con aplicaciones "traducibles"
Todos los textos de la interfaz gráfica, se gestionan de forma automática, de modo que al acudir al gestor de traducciones, los encontrarás disponibles tras cualquier cambio o adición en la intefaz.

En cuanto a los textos del programa, hemos de indicar explícitamente que deseamos tenerlos disponibles para su traducción, ya que podría tratarse de textos que no se deben traducir, como, por ejemplo, cadenas SQL, o etiquetas de XML. Si en un código no traducible, indicamos las cadenas como en este ejemplo:

PUBLIC SUB Button1_Click()

Message.Info ("Hola Mundo")

END

En el caso de un texto ha traducir, hemos de delimitar la cadena textual con signos de paréntesis:

PUBLIC SUB Button1_Click()

Message.Info ( ("Hola Mundo") )

END

El compilador sabe distinguir automáticamente entre los paráentesis que corresponden al método, y los referidos a la cadena.

Por último, ten en cuenta que hay signos especiales o "de escape" en Gambas; así, por ejemplo, el símbolo " & " se utiliza para indicar en la interfaz gráfica, que esa tecla será el atajo de teclado para acceder al menú o botón, por ejemplo. Otros símbolos tienen significado similar al que tienen en C o algunas shells, como es el caso de "\n" (retorno de carro). el gestor de traducciones, es capaz de comprobar la coherencia de caracteres especiales escritos en la versión original, y en la traducción.

10. Proceso de Traducción


Vamos a tomar como ejemplo el propio entorno de desarrollo Gambas. Cuando descargamos una versión de Gambas en paquete fuente, y descomprimimos el paquete tar.bz2, se genera una carpeta llamada gambas-X.XX (X.XX depende de la versión). Dentro de esta carpeta, hay dos subcarpetas:
app/gambas : contiene el propio entorno de desarrollo.
app/gambas-database-manager : contiene el gestor de bases de datos.
Pues bien, ejecutemos Gambas, indiquemos "Abrir proyecto", busquemos la carpeta gambas-X.XX/app/gambas, y abramos este proyecto. A continuación, acudamos al menú "Proyecto", seleccionando la opción "Traducir".




Una vez seleccionada la opción, entramos en el asistente de traducción. Hemos de elegir el idioma que deseamos traducir. Si ya habíamos trabajado previamente en ella, aparecerán los textos sin traducir, así como los ya traducidos. Todas las cadenas sin traducir, así como las introducidas con posterioridad a la última fase de traducciones, aparecerán con la traducción en blanco.




Cada vez que pulsamos con el botón izquierdo en una de las cadenas en la primera lista, en las listas inferiores se nos muestra la cadena original, y en la parte inferior disponemos de la caja de texto para escribir la traducción correspondiente. Cuando cambiamos a otra cadena, la que habíamos editado queda guardada durante esta sesión (es necesario pulsar "Guardar traducción" para que quede guardado permanentemente).
El resto de las opciones son las siguientes:

• Guardar traducción : los cambios realizados en esta sesión, se guardan y quedan disponibles para los usuarios del programa en ese idioma.
• Recargar traducción : se borran todos los cambios realizados en la última sesión, y se vuelve al estado anterior.
• Borrar traducción : elimina todos los textos traducidos.
• Duplicar una traducción : hace una copia de la traducción que había en otro idioma, de modo que nos sirva como base para el idioma a traducir. Puede ser útil, por ejemplo, para hacer una traducción en "Español (variante Argentina)", basada en la original "Español (variante España)". Lo mismo ocurre con el Francés de Bélgica o Canadá respecto al de Francia, que puede llegar a ser confuso según la nacionalidad del usuario, si no se realizan adaptaciones.
• Exportar una traducción : convierte la traducción en un fichero estándar tipo ".po", usado por la mayoría de los programas escritos en C y C++ sobre GNU/Linux, FreeBSD y software libre para otros sistemas operativos. este formato permite enviar la traducción realizada a otras personas, en un sistema de desarrollo donde se trabaje en diferentes lugares. Este es el caso de Gambas: una vez escrita la traducción, se exporta a formato .po, y se envía a la lista de desarrollo de Gambas.
• Importar una traducción : proceso inverso al anterior. El coordinador recibe un fichero ".po", y lo absorve para incorporarlo a la versión de programa.
• Verificar traducción : imprescindible antes de dar por buena una nueva versión, comprueba que todos los símbolos especiales (por ejemplo '&') coinciden entre los textos originales y los traducidos. No debe utilizarse, ni exportarse nunca, una traducción en la cual el verificador da un mensaje de error.
• Buscar la siguiente cadena no traducida : nos dirige directamente a la siguiente cadena pendiente de traducir desde la anterior traducción, de modo que sea más fácil traducir conforme se incorporan nuevas cadenas al programa.

Y con esto y un bizcocho, se acabó el tutorial Básico de gambas, espero que os sea útil

Salu2
Choms

Esto todo muy bueno!! pero si quiero instalar en otra computadora. ¿como se hace?
¿como se crea el instalador del proyecto creado?

no se si te entiendo... te refieres a compilarlo como ejecutable o a crear un instalador tipo install shield?

a lo primero sencillo, supongo yo que el gambas traerá compilador de serie
a lo segundo te tienes que buscar un programa que te haga los instaladores (yo antes usaba uno muy bueno para windows que se llama Inno Setup)

De todas maneras te miro mejor lo primero y luego te concreto

Salu2

Me acabo de poner linux, y como comprenderéis no conozco mucho el tema todavía, pero como hace poco me puse a hacer cosas con el Visual Basic y me gustó bastante, pues me gustaría ponerme el gambas que parece ser igual. Alguien sabe como me lo puedo bajar del sinaptic?

El Synaptic tiene un boton de busqueda, ahi buscas el programa que quieras instalar y te saldrá una lista, seleccionas el que quieres, le das a aplicar, y ya está

Ya lo hice i tecleando gambas no me salio, es un problema de mi linux o es que he de teclear otra cosa?

que distro usas? por lo general tendria que estar el gambas, en todas las distros que he usado tenia gambas...

Uso ubuntu... Aunque tambien me pasa que no me actualiza, es como si ya estuviesse actualizado y lleva un tiempo asi...