Imagenes con goocanvasmm

Este es un mini tutorial de imagenes con goocanvasmm

1.  
2. #include <gtkmm.h>
3. #include <goocanvasmm.h>
4. #include <cairomm/cairomm.h>
5. #include <iostream>
6. #include <gdkmm-2.4/gdkmm.h>
7.  
8. using namespace Goocanvas;
9. using namespace Glib;
10. using namespace std;
11. using Gdk::InterpType;
12.  
13. // Clase imagen personalizada
14. class Imagen: public Goocanvas::Image{
15. protected:
16.    
17.     Imagen(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf, double x = 0.0, double y = 0.0):
18.         Goocanvas::Image(pixbuf,x,y){   }  
19. public:
20.  
21.     static Glib::RefPtr<Imagen> create(double x = 0, double y = 0, double width = 0, double height = 0){
22.         // Crea un buffer de pixeles a partir del fichero de la imagen
23.         Glib::RefPtr<Gdk::Pixbuf> pb= Gdk::Pixbuf::create_from_file("toroid.png",width,height,true) ;
24.        
25.         // Crea una imagen a partir del pixbuf
26.         Imagen *imagen=new Imagen(pb,x,y);
27.        
28.         // Asigna la posición de la imagen
29.         imagen->set_bounds(Bounds(x,y,x+width,y+height));
30.        
31.         // Retorna la imagen creada
32.         return Glib::RefPtr<Imagen>(imagen);
33.     }
34. };
35.  
36. // ventana principal
37. class Simple : public Gtk::Window
38. {
39. public:
40.     Simple(){
41.         // Asigna un tamaño a la plantilla raiz
42.         lienzoImagen.set_size_request(800, 800);
43.  
44.         // Establece la ubicación de la plantilla en la pantalla
45.         lienzoImagen.set_bounds(0, 0, 800, 800);       
46.  
47.         // Crea un imagen y lo asigna a lienzo, recuerda que
48.         // el lienzoImagen solo es el contenedor
49.         imagen = Imagen::create(100, 100, 450, 450);
50.  
51.         // Asigna el color interno del imagen
52.         imagen->property_fill_color().set_value("blue");
53.  
54.         // Asocia la señal de clickeo del imagen con el método
55.         // imagen_clicked() del objeto actual
56.         imagen->signal_button_press_event ().connect (sigc::mem_fun (this,
57.                 &Simple::imagen_clicked));     
58.  
59.         // Retorna el item root de la plantilla
60.         RefPtr<Item> root = lienzoImagen.get_root_item();
61.  
62.         // Agrega el imagen a la plantilla
63.         root->add_child(imagen);
64.  
65.         // Agrega el lienzo a la ventana actual
66.         add(lienzoImagen);
67.  
68.         show_all_children();
69.     }
70.  
71.     /** Método que se ejecuta cuando se clickea el imagen **/
72.     bool imagen_clicked(const RefPtr<Item>&, GdkEventButton*){
73.         cout << "Has clickeado el imagen" << endl ;
74.         return true ;
75.     }
76.  
77.     Glib::RefPtr<Imagen> m_item;
78.  
79. protected:
80.     // Lienzo contenedor del imagen
81.     Canvas lienzoImagen;
82.    
83.     // Imagen a mostrar
84.     RefPtr<Imagen> imagen;
85. };
86.  
87.  
88.  
89. int main(int argc, char* argv[]){
90.     Gtk::Main app(&argc, &argv) ;
91.  
92.     // Inicializa goocanvas. Es necesario en todo programa que use esta biblioteca
93.     Goocanvas::init("Ejemplo simple goocanvasmm", "1.0", argc, argv) ;
94.  
95.     Simple ventana ;
96.  
97.     Gtk::Main::run(ventana) ;
98. }
99.  

Usar librerías boost en eclipse

Antes que nada deberás tener instaladas las librerías, para ella puedes instalarla desde tu gestor de software. Las básicas son:

boost
boost-system
boost-devel

En el caso de Fedora existen varios paquetes para usos específicos (expresiones regulares, timers, etc). Recomiendo instalarlos todos. Estos son algunos:

Luego de instalar los paquetes entras en eclipse e entras en el fichero objects.mk de tu proyecto

y agregas el string -lboost_system-mt a la variable LIBS.

Quedaria algo asi:

LIBS := -lglib-2.0 -lboost_system-mt

Nota: Algunas características de boost necesitan links a otras librerías. Por ejemplo si deseas usar timers debes agregar -lpthread.

Este proceso tambien se puede hacer desde el dialogo de opciones del proyecto:

C/C++ Build -> Settings -> GCC C++ Linker -> Libraries

Allí agregas la biblioteca deseada.

Pelar un cable ffc

He buscado en mil foros y no consegui como c... podia pelar un cable ffc (Flex). En mi desesperación para exponer el cobre del cable ffc utilice un dremel con punta de lija y funcionó perfecto. Solo hay que cuidarse de no afincar el cable contra el dremel.

Programar un Arduino Pro Mini con un Uno / Duemilanove

Primero debe quitarle el atmega al Uno o Duemilanove
Las conexiones son las siguientes:

Duemilanove |  Pro Mini

          Reset  |  GRN

            3V3  |  VCC

           GND |  GND

             TX  |  TX

             RX  |  RX

Luego ir a Arduino IDE y seleccionar la tarjeta como el modelo Arduino Pro Mini . Seleccione el modelo a programar. En mi caso es del de 3.3v  8 Mhz Atmega328

y listo.

Configuración multimonitor en GNU / Linux con KDE

Si deseamos un entorno con con varios escritorios asignados a distintos monitores corriendo bajo Linux, la mejor opción es KDE.

Nos permite ajustar la configuración en un tris. Este es mi escritorio

Aunque en la captura aparezca como una sola imagen, en realidad son dos monitores cada uno con un escritorio distinto y una barra de tareas especifica. El relleno negro que se observa en el escritorio de la derecha no se ve en el monitor, puesto que solo es un relleno ocasionado por las distintas resoluciones con que trabajan mis dos monitores.

La configuración de los monitores (clonado, extendido etc) se hace directamente desde el panel de control que ofrezca el fabricante de su tarjeta gráfica (AMD | Ati, Nvidia...) en mi caso AMD Hd 6870.

En este caso es un monitor extendido.

Para que en el gestor de tareas muestre solo las aplicaciones que están en el monitor actual ve a las preferencias del gestor de tareas (clic secundario en él) y luego selecciona todos los check buttons de los filtros, menos el ultimo. Has esto por cada gestor de tareas que poseas.

  

Así se ve mi pc trabajando con doble monitor bajo Fedora 17 x64 con KDE

NIC dedicada a una VM en Virtualbox

A algunas personas nos pasa el caso en donde poseemos dos conexiones a internet y deseamos aprovecharlas. Para ello he hecho varias configuraciones con bonding pero sigue sin convencerme. Esperaré a que fedora 18 sea liberada para probar con libteam y teamd.

Mientras tanto, he ideado la siguiente configuración para dar uso a mis dos interfaces.

Tengo dos NIC's alambicas. Una conectada a un range extender con el cual "pido prestado" el super wifi de algún vecino (2 Mb/s) y la otra a un servicio adsl estándar (1 Mb/s). Con las dos suman 3 megas de velocidad, que aquí en Venezuela es una barbaridad.

A la maquina virtual (cliente) le asigné la conexión de 2 Mb/s y al host la de 1 Mb/s. 

Para ello:

- Abrí la configuración de la maquina virtual

- Luego en el menu "Red" seleccioné adaptador puente y en el campo nombre debes selecciona la interfaz que será tu dedicada (en mi caso se llama "p1p1"). Le das en ok y listo.

Si usted tiene instalado algún monitor de red notará que ambas NIC's están trabajando.

Ahora puede ver un video de Pamela Anderson en el host mientras carga la saga completa de Paris Hilton en la maquina virtual y todo fluido XD

Así se ven mis conexiones hoy:

Ver el PID de una aplicación (ventana)

Si necesita saber el pid de una aplicación, asociada a una ventana, puede usar el comando xprop.

Si lo ejecuta en un terminal y entonces el puntero cambiara a una cruz y le dará clic a la ventana de la aplicación deseada.

En el caso de la imagen el PID seria 2620.

Si no quieres buscar entre tanta letra puedes filtrarlo con xprop | grep "PID"

Existen otras alternativas para buscar el pid como:
pgrep nombredelproceso
o el clásico
ps -e | grep nombredelproceso

Pero para gustos colores.