Compilar un programa escrito en C# con Mono, GTK#, Cairo

Les cuento que Mono incorpora Cairo, que es una librería originalmente escrita en C, para el renderizado de dibujos en 2D (2 dimensiones). Que funciona con o sin aceleración gráfica para tarjetas de video. Se dice que simple de utilizar y se incorpora perfectamente con GTK, las librerías que utiliza Gnome uno de los escritorios mas utilizados en Linux.

Ahora les presento un código que hice yo, para que vean como es, espero que les guste.

    // Compilar: gmcs Clip2.cs -pkg:gtk-sharp-2.0 -r:Mono.Cairo

    using System;
    using Cairo;
    using Gtk;
    using System.Timers;

    public class GtkCairo
    {
     static void Main ()
     {
     Application.Init ();
     Gtk.Window w = new Gtk.Window ("Clip2");

     DrawingArea a = new CairoGraphic ();
     Box box = new VBox (true, 0);
     box.Add (a);

     w.Add (box);
     w.Resize (256, 256);

     w.DeleteEvent += close_window;
     w.ShowAll ();

     Application.Run ();
     }

     static void close_window (object obj, DeleteEventArgs args)
     {
     Application.Quit ();
     }

    }

    public class CairoGraphic : DrawingArea
    {
     private static double grosorLinea;
     private static double transparencia;
     private static bool contraerLinea;
     private static bool expanderLinea;
     private static bool transparenciaPos;
     private static bool transparenciaNeg;

     public CairoGraphic ()
     {
     transparenciaPos = expanderLinea = true;
     transparenciaNeg = contraerLinea = false;
     GLib.Timeout.Add (100, new GLib.TimeoutHandler (Siempre));
     grosorLinea = 20.0;
     transparencia = 0.20;
     }

     private bool Siempre ()
     {
     QueueDraw ();
     return true;
     }

     protected override bool OnExposeEvent (Gdk.EventExpose args)
     {
     //
     // Expander y contraer lineas
     //
     if (expanderLinea == true) {
     grosorLinea += 0.5;
     if (grosorLinea > 24.0) {
     expanderLinea = false;
     contraerLinea = true;
     }
     }
     else if (contraerLinea == true) {
     grosorLinea -= 0.5;
     if (grosorLinea < 21.0) {
     contraerLinea = false;
     expanderLinea = true;
     }
     }
     //
     // Aumentar y Reducir transparencia
     //
     if (transparenciaPos == true) {
     transparencia += 0.01;
     if (transparencia > 0.99) {
     transparenciaPos = false;
     transparenciaNeg = true;
     }
     }
     else if (transparenciaNeg == true) {
     transparencia -= 0.01;
     if (transparencia < 0.50) {
     transparenciaNeg = false;
     transparenciaPos = true;
     }
     }

     double PI = System.Math.PI;

     using (Context g = Gdk.CairoHelper.Create (args.Window)){
     g.Arc (128.0, 128.0, 76.8, 0, 2*PI);
     g.Clip ();
     g.NewPath ();
     g.Rectangle (0,0,256,256);
     g.Fill (); // Transfiere el Color que pasa por la mascara

     //
     // Dibuja la X
     //
     g.SetSourceRGBA (0,1,0,transparencia); // Color Verde
     g.MoveTo (0,0);
     g.LineTo (256,256);
     g.MoveTo (256,0);
     g.LineTo (0,256);

     g.LineWidth = grosorLinea;
     g.Stroke (); // Transfiere la X

     }

     return true;
     }
    }

Se compila así:

gmcs Clip2.cs -pkg:gtk-sharp-2.0 -r:Mono.Cairo

Hasta hice un video, de el programa: http://www.youtube.com/watch?v=Hr-fqaMwvLM y también lo publique en los Foro de Programación X, y ahí esta el código fuente.

Ejemplo mínimo en C++ con librería Glut y OpenGL (Linux)

También pueden ver este tema completo acá.

Hoy quiero presentar un ejemplo que hice recién, para los que se quieran adentrar en el mundo del OpenGl con C++, Linux y Glut. Lo traté de hacer lo mas simple posible, por lo tanto es un dibujo plano en dos dimensiones (2D).

Imágen de una ventana con el ejemplo

Imágen de una ventana con el ejemplo

Aquí va:

/* Simple.cpp
 * compilar: g++ simple.cpp -o simple -lglut
 * by Writkas
 */

#include <GL/glut.h>

void display(void)
{
 // Borra los valores preajustados
 glClear(GL_COLOR_BUFFER_BIT); 

 // Delimita los vértices de una primitiva o un grupo de como primitivas
 // , GL_POLYGON es el modo que se a seleccionado.
 glBegin(GL_POLYGON);
 // Indica los puntos que se trazan en un plano cartesiano para
 // formar la figura. En el identificador "glVertex2f" el numero
 // "2" indica el número de argumentos y "f" el tipo de dato que
 // se pasa como argumento. En el caso de la f es float.
 glVertex2f(-0.5, -0.5);
 glVertex2f(-0.5, 0.5);
 glVertex2f(0.5, 0.5);
 glVertex2f(0.5, -0.5);
 // Termina de dibujar.    
 glEnd();

 // Fuerza de la ejecución de comandos en OpenGl
 glFlush();
}

int main(int argc, char** argv)
{
 // Se inicia el modo Glut, los argumentos son para enviar ordenes
 // externas al programa.
 glutInit(&argc,argv);
 // Inicializa el modo de visualización del programa, si está en modo
 // GLUT_SINGLE significa que tendrá un solo bufer. Lo que guardará la
 // imagen para luego mostrarla. Y el modo GLUT_RGB se asigna el modo
 // color. RGB resume "Red, Green, Blue".
 glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
 // El tamaño de la ventana 500 Píxeles de ancho y alto.  
 glutInitWindowSize(500,500);
 // Indica la posición de la ventana.
 glutInitWindowPosition(0,0);
 // Define la ventana y le añade el título "simple".
 glutCreateWindow("simple");
 // Enviar una función para que se ejecute de forma independiente. Se
 // dice que es conectar la señal "display".
 glutDisplayFunc(display);

 // Empieza todo lo dicho anteriormente. Se mantiene ejecutando la
 // ventana y esperando cualquier evento dicho anteriormente, u otros
 // predefinido por glut. Por ejemplo, se espera que alguien presione
 // la x de la ventana para salir del programa.
 glutMainLoop();
}

Se puede compilar con Make:

.../simples$ make

O compilarlo de forma:

g++ Simple.cpp -lglut -o main

Hay que tener muy en cuenta que se necesitan instalar las librerías necesarias. Y el archivo esta adjunto al post del tema del foro www.programacion-x-foro.tk

MySQL al vuelo, en Linux

Este es un artículo que hice hace mucho tiempo, lo quería publicar pero está muy desordenado. Lo puse como si fuera un código fuente ya que así no se modifica el formato del artículo. Lo que trata este artículo es un vistazo rápido de como se usa MySQL. No explico para nada, de que trata una base de datos ni cosas teóricas. Es solo a lo práctico, para las personas que tienen una idea de que son y para que sirven las bases de datos.

MySQL al vuelo, en Linux
Mas que nada esto son unos pequeños apuntes que hice para mi, y tal vez se pueda descifrar:

Hay que abrir el monitor MySQL, en Linux. En Win igual hay un monitor de MySQL:

writkas@writkas-desktop:~$ sudo mysql -u root -h localhost -p

se abre el monitor de mysql en el servidor local, osea en mi pc.
-u indica el nombre del usuario, root para poder crear y eliminar bases de datos
-h indica el nombre del host
-p para que pida password (la contraseña es la misma que tu usuario root)

El comando anterior muestra:

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 154
Server version: 5.0.67-0ubuntu6 (Ubuntu)
Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

Una vez dentro del shell MySql, podemos ver las bases de datos con:

mysql show databases;

Muestra:

+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
+--------------------+
2 rows in set (0.00 sec)

Creo una base de datos con el nombre ‘Foro’:

mysql create database Foro;

Muestra:

Query OK, 1 row affected (0.00 sec)

Ahora la puedes ver creada con:

mysql show databases;

Muestra:

+--------------------+
| Database           |
+--------------------+
| information_schema |
| Foro               |
| mysql              |
+--------------------+
3 rows in set (0.00 sec)

Para eliminar la base de datos ‘Foro’ se utiliza:

mysql drop database Foro;

Muestra:

Query OK, 0 rows affected (0.01 sec)

La creamos de nuevo:

mysql create database Foro;

Muestra:

Query OK, 1 row affected (0.00 sec)

Para usar una base de datos, en el caso de que se quiera crear tablas, etc.
Vuelvo con el ejemplo de la base de datos ‘Foro’ :

mysql use Foro;

Muestra:

Database changed

Luego de haber indicado que base de datos se utiliza, con la palabra ‘use’, se
pueden ver las tablas. Pero en este caso no mostrará ninguna por que no la he creado:

mysql show tables;

Muestra:

Empty set (0.00 sec)

Ahora para crear una tabla ‘Usuarios’ que contenga los usuarios del foro:

mysql create table Usuarios (usuariosID int unsigned not null auto_increment primary key, nombre char(30) not null, direccion varchar(50) not null, ciudad varchar(50) not null, edad tinyint unsigned not null);

Muestra:

Query OK, 0 rows affected (0.00 sec)

con ‘create table’ se crea una tabla con el identificador ‘Usuarios’ luego entre paréntesis
se definen cada uno de los campos. ‘usuariosID’ es un identificador que referencia a datos
tipo ‘int unsigned’, enteros sin signos (solo números positivos). ‘not null’ indica que no
debe ser nulo, no entiendo muy bien esto… ‘auto_increment’ indica que automáticamente, el
numero entero que contiene, va a ser incrementado en 1 si el valor no es asignado. En el
caso de que el numero si sea asignado estará bien pero NO debe repetirse en la tabla
‘Usuarios’, esto último es gracias a la palabra ‘primary key’. Si se especifica un valor en
el campo ‘usuariosID’ el próximo que no se especifique sera un numero +1 que el anterior.
‘,’ Indica que se va a definir otros campos. ‘nombre’ es el identificador de un tipo de
variable que tiene 30 caracteres lo que también en MySQL es equivalente a 30 bytes,
cerradamente si no contiene 30 bytes se rellena. Siempre son 30 bytes. ‘direccion’ es el
identificador de un tipo de variable que contiene caracteres, como máximo son 50, pero al
contrario que ‘char’ este valor se redondea a el numero de caracteres que ocupe. Por que se
utilizan estos dos tipos, varchar y char, es que char es mas rápido al no tener que redondiar
para ahorrar espacio. ‘edad’ es un identificador de un tipo de variable ‘tinyint unsigned’
que no es mas que una pequeña variable entera sin signo, a diferencia de int es que int es
mas grande.

El siguiente comando muestra la tabla creada:

mysql describe Usuarios;

Muestra:

+------------+---------------------+------+-----+---------+----------------+
| Field      | Type                | Null | Key | Default | Extra          |
+------------+---------------------+------+-----+---------+----------------+
| UsuariosID | int(10) unsigned    | NO   | PRI | NULL    | auto_increment |
| nombre     | char(30)            | NO   |     | NULL    |                |
| direccion  | varchar(50)         | NO   |     | NULL    |                |
| ciudad     | varchar(50)         | NO   |     | NULL    |                |
| edad       | tinyint(3) unsigned | NO   |     | NULL    |                |
+------------+---------------------+------+-----+---------+----------------+
5 rows in set (0.03 sec)

Para insertar datos en la tabla, en cada uno de los campos se puede hacer de esta manera:

mysql&gt; insert into Usuarios values (null, 'Writkas sss', 'Angamos 9750', 'Victoria', 99);

De otra manera se podría hacer así:

mysql&gt; insert into Usuarios set nombre = 'Writkos', direccion = 'Arturo Prat 999',
ciudad = 'victoria', edad = '1';

Muestra:

Query OK, 1 row affected (0.00 sec)

Ahora para mostrar los datos agregados:

mysql&gt; select * from Usuarios;

Muestra:

+------------+-------------+-----------------+----------+------+
| UsuariosID | nombre      | direccion       | ciudad   | edad |
+------------+-------------+-----------------+----------+------+
|          1 | Writkas sss | Angamos 9750    | Victoria |   55 |
|          2 | Writkos     | Arturo Prat 999 | victoria |    1 |
+------------+-------------+-----------------+----------+------+
2 rows in set (0.00 sec)

Para ver solo algunos campos se puede utilizar:

mysql&gt; select nombre, ciudad from Usuarios;

Muestra:

+-------------+----------+
| nombre      | ciudad   |
+-------------+----------+
| Writkas sss | Victoria |
| Writkos     | victoria |
+-------------+----------+
2 rows in set (0.00 sec)

Para ver los mismo campos pero con un limite de lineas:

mysql&gt; select nombre, ciudad from Usuarios limit 0,1;

Muestra:

+-------------+----------+
| nombre      | ciudad   |
+-------------+----------+
| Writkas sss | Victoria |
+-------------+----------+
1 row in set (0.00 sec)

Para buscar segun algun criterio:

mysql&gt; select * from Usuarios where edad=1;

Muestra:

+------------+---------+-----------------+----------+------+
| UsuariosID | nombre  | direccion       | ciudad   | edad |
+------------+---------+-----------------+----------+------+
|          2 | Writkos | Arturo Prat 999 | victoria |    1 |
+------------+---------+-----------------+----------+------+
1 row in set (0.00 sec)

Abría mucho mas que mostrar pero en el momento que escribí esto tenía mucho sueño…

Como ven no es para nada teórico.