Editor de eBooks usando GTK+

Investigando sobre Mono, DocBook y Open eBook

2006-01-20T20:09:00.000-04:00

He estado investigando alternativas para el desarrollo e implementación, pero todo parece indicar que me quedaré con GTK+.

Hoy probé con Mono a sugerencia de un amigo, pero Mono depende (en Windows) de la suite .NET, y no pienso depender de dicha suite para mi trabajo. Además, no existen versiones bajo Windows de MonoDevelop (el ambiente de desarrollo de Mono), sino solo para MacOS X y Linux. Intenté con SharpDevelop, otra suite de C# open source, pero también depende de la instalación de los runtimes de .NET, así que... ¡descartada!

Microsoft también afecta el formato XML que había escogido para los libros electrónics, Open eBook. Como patrocinante "golden" del International Digital Publishing Forum, Microsoft está interesada en buscar que el formato soporte Administración de Restricciones Digitales (DRM), algo que está en contra de los propósitos de mi proyecto.

Por ello he estado averiguando esta semana en otros formatos XML para libros electrónicos, fundamentalmente OpenReader y DocBook

Es importante usar -mno-cygwin

2006-01-11T20:05:00.000-04:00

Corrijo el post anterior para indicar que se debe añadir el parámetro "-mno-cygwin" al llamar al compilador, o de lo contrario habrán errores de ejecución al tratar con clases de la biblioteca Glib. Particularmente yo tenía problemas con Glib::Dir.read_name().

g++ oebeditor.cc -o oebeditor `pkg-config --cflags --libs libglademm-2.4` -mms-bitfields -mno-cygwin

Usando Glade y Libglademm bajo Cygwin

2006-01-10T14:37:00.000-04:00

He continuado el proyecto pero no sin problemas.

Utilizar GTK+ con el lenguaje C++ y el compilador Cygwin no es algo que se haya hecho con mucha frecuencia. Sólo cinco por ciento de los proyectos en GTK+ se hacen en C++ (casi el el noventa por ciento se hacen en lenguaje C), y casi todos en Linux.

Como había explicado antes, una de mis opciones era usar el editor de interfaces Glade para generar mis ventanas, y usar el programa glademm para generar el código en C++ desde Glade. Lamentablemente, glademm no funciona bajo Windows y la mayoría de las personas que usan GTK+ recomiendan usar libglademm en vez de glademm.

LibGlademm es una librería que permite utilizar, desde el ejecutable, el archivo que genera Glade (el cual es un archivo XML de extensión .glade). Pero inicialmente muchos de los ejemplos de código que uno encontraba en Internet no compilaban adecuadamente desde Cygwin bajo Windows.

Este fragmento de código es el que finalmente me logró funcionar. Es mi clase principal (oebeditor.cc) y requiere de un archivo .glade (que llamaremos oebeditor.glade y lo colocaremos en la misma carpeta donde se genere el ejecutable) que tenga un widget llamado vboxMain, del tipo vertical box (es un contenedor de Glade que permite agrupar widgets verticalmente, como se ve a la derecha).

Se requiere instalar desde dentro de Cygwin los módulos correspondientes a Gtk+ y gtkmm, entre otros.

Para compilar, se usa el comando (desde el bash de cygwin):

g++ oebeditor.cc -o oebeditor `pkg-config --cflags --libs libglademm-2.4` -mms-bitfields

oebeditor.cc

#include <libglademm/xml.h>
#include <gtkmm.h>
#include <iostream>

#include <iomanip>
#include <sstream>
#include <sigc++/retype_return.h>

#include "oebeditor.h"

//using namespace std;

oebeditor::oebeditor()
{

    Gtk::VBox *vboxMain;     
       
    // Tamaño y título de la ventana
    set_title("Prueba");   
    resize(770,500);   
   
    // Prepararse para cargar el archivo .glade   
    try
    {
        // Nota: Desde Glade, es necesario ponerle la propiedad "visible"
        // en falso a la ventana (window) principal del .glade, o sino en
        // este punto se mostrarán dos ventanas a la vez.       
        refXml = Gnome::Glade::Xml::create("oebeditor.glade");       
       
        refXml->get_widget("vboxMain", vboxMain);
       
         vboxMain->reparent(*this);        
    }
    catch(const Gnome::Glade::XmlError& ex)
    {
        std::cerr << ex.what() << std::endl;
    }
   
    if(vboxMain)
    {
   
        Gtk::MenuItem* pMenuItem = 0;
       
        // ---------------------------------------------------------------
        // Se conecta cada opción del menú con un método que será invocado
        // cuando el usuario seleccione dicha función
       

        // Abrir proyecto
        refXml->get_widget("menu_abrir", pMenuItem);       
        if(pMenuItem) pMenuItem->signal_activate().connect( sigc::mem_fun(*this, &oebeditor::on_abrir_activate) );

        // Salir
        refXml->get_widget("menu_salir", pMenuItem);       
        if(pMenuItem) pMenuItem->signal_activate().connect( sigc::mem_fun(*this, &oebeditor::on_salir_activate) );

    }

}

oebeditor::~oebeditor()
{
}

/* ---------------------
   CREAR NUEVO PROYECTO
 --------------------- */

void oebeditor::on_nuevo_activate()
{
}

/* ---------------------
   ABRIR NUEVO PROYECTO
 --------------------- */
void oebeditor::on_abrir_activate()
{
    // --------------------------------------
    //  Pregunta al usuario dónde se encuentra
    //  el proyecto a abrir
    // --------------------------------------
   
   
    abrirproyecto* p = new abrirproyecto();
    p->set_transient_for(*this);
    p->show_it();
    //p->set_transient_for(*this);
   
 }


/* ---------------------
   CERRAR PROYECTO
 --------------------- */
void oebeditor::on_cerrar_activate()
{
}


/* ---------------------
    GUARDAR
 --------------------- */
void oebeditor::on_guardar_activate()
{
}

/* ---------------------
    GUARDAR COMO
 --------------------- */
void oebeditor::on_guardarcomo_activate()
{
}

/* ---------------------
    PROPIEDADES
 --------------------- */
void oebeditor::on_propiedades_activate()
{
}

/* ---------------------
   SALIR
 --------------------- */
void oebeditor::on_salir_activate()
{
    // TO DO: verificar si el proyecto no ha sido guardado
    hide();
}

int main (int argc, char *argv[])
{

// This main function merely instantiates the ogcalc class
// and displays it.
  Gtk::Main kit(argc, argv); // Initialise GTK+.

  oebeditor window;   // Create an ogcalc object.
  kit.run(window); // Show window; return when it's closed.

  return 0;
}

Este es el archivo oebeditor.h

#include <gtkmm.h>
#include <libglademm.h>
#include "abrirproyecto.h"

class oebeditor  : public Gtk::Window
{
    public:
     oebeditor();
     virtual ~oebeditor();     
     void on_abrir_activate();
     void on_salir_activate();

    protected:
        Glib::RefPtr<Gnome::Glade::Xml> refXml;

         
        //Gtk::Window* pWindow;
        
        // Glade interface description.
        Glib::RefPtr<Gnome::Glade::Xml> xml_interface;
  
};

Trabajando con Dev-C++ y GTK+ bajo Windows

2005-10-13T12:17:00.000-04:00

Bueno, retomando la tesis, tuve que aprender a punta de golpes cómo usar el ambiente de programación Dev-C++ de la empresa Bloodshed con GTK+.

Como se sabe, GTK+ es un conjunto de bibliotecas que permiten crear aplicaciones con interfaz gráfica, que funcionan muy bien bajo Gnome (en Linux) y bajo Windows. Con ella se han hecho aplicaciones como The Gimp (un programa de edición de bitmaps similar a Photoshop) y funciona en una gran variedad de lenguajes, entre ellos C++. Utiliza una licencia software libre.

Dev-C++, por su parte, es un ambiente de programación también considerado software libre, programado bajo Delphi y que permite programar en C y C++ bajo Windows con un ambiente compatible con GNU, usando al compilador MingW (Minimalist GNU for Windows).

Las instrucciones para trabajar con todo esto al mismo tiempo son las siguentes:

Descarga e instala primero la versión 5 de Dev-C++.
Bajar e instalar el ambiente de desarrollo Glade/GTK+ para Windows según se indica en el post anterior. Yo bajé e instalé el Gtk+/Win32 Development Environment Installer 2.8.6-rc1. El instalador deberá señalar que encontró a Dev-C++ y le está colocando los enlaces necesarios.
Ingresa a http://gtk.alkia.org y descarga el paquete "GTK 2.8.0 Runtime for Windows". Este es un archivo .DevPack que permite que el ambiente de desarrollo Dev-C++ vea los archivos de cabecera y les dé uso. Si por casualidad ese sitio web deja de funcionar, ingresa a www.devpaks.org y, en la sección GTK, descarga GTK+ 2.6.8 y los paquetes adicionales requeridos.
Iniciar Dev-C++. Ir al menú File -> New -> Project.
Seleccionar en la pestaña superior, "GUI".
Seleccionar "GTK+" y "C++ Project". Colocarle un nombre al proyecto y presionar Ok.
Se generará el código fuente de una ventana en blanco. Pero cuando trates de compilar, te dará un sinnúmero de errores porque el compilador no encontrará los archivos de cabecera de GTK+. Tienes que añadirlos a mano.
Selecciona en el menú "Tools" el ítem "Compiler Options". Selecciona "Directories" y luego "C++ Includes".
Busca y añade las carpetas mostradas arriba: include\gtk-2.0, include\cairo, include\glib-2.0, include\pango-1.0, lib\glib-2.0\include, lib\gtk-2.0\include e include\atk-1.0.
Dale Aceptar. Verás que, cuando intentes compilar, te aparece este error:

"Gtk-ERROR **: Incompatible build! The code using GTK+ thinks GtkBox is of different size than it actually is in this build of GTK+."
Tal y como lo dice la ventana, lo que hay que hacer es ingresar nuevamente en "Tools" y luego en "Compiler Options". en la pestaña "Compiler", chequea la opción "Add the following commands when calling compiler" y en el espacio indicado coloca "-mms-bitfields" (sin las comillas). Dale aceptar.
Recompila el proyecto completamente con la opción Execute -> Rebuild all.
¡Listo! Al ejecutar, te aparecerá algo como:

Compilando un proyecto de Glade en C++ con Cygwin

2005-08-05T14:37:00.000-04:00

Finalmente lo he logrado :) :) :) ¡Luego de dos semanas pariendo perdido por caminos verdes, al final lo logré! ¡Compilé bajo Windows un proyecto generado por Glade en C++!

Los pasos son los siguientes:

Bajar y descargar Glade/GTK+ para Windows desde http://gladewin32.sourceforge.net/. Este paquete es lo único que se necesita si quieres diseñar interfaces de usuario y generar código en C. Ese código es perfectamente compilable desde Microsoft Visual C++ 6 (simplemente genera el código desde Glade, luego abres el Visual Studio, seleccionas "Abrir proyecto", vas a la carpeta msvc y abres el archivo .dsw respectivo).
Lamentablemente, este paquete no servirá para generar código en C++ pues reventará con este error:

# Error running glade-- to generate the C++ source code. Check that you have glade-- installed and that it is in your PATH. Then try running 'glade-- ' in a terminal.

Se intentó con este ejecutable de glade--.exe sin resultado alguno (el mismo hacía crash).

Usando Cygwin y gtkmm para Windows

La solución consistirá en utilizar una distribución llamada gtkmm for Win32, que sí funciona muy bien bajo Windows. Sin embargo, la misma no utiliza Visual C++ 6 sino el ambiente de compilación Cygwin, el cual trata de imitar de una forma muy cercana al conjunto de herramientas de programación para C y C++ que existen bajo Linux: GCC, autoconf, automake, libtool, etc.

También es posible utilizar MSVC .NET (versión 7.1), pero los autores de gtkmm para Windows advierten de un bug bastante grave con el que se han topado algunas aplicaciones siendo programadas con esta combinación. Para solucionarlo hay que actualizarse al beta 2 de Visual Studio. Net 2005. El mismo ya está disponible; sin embargo, Visual Studio .Net es una plataforma demasiado pesada para mí, además de que es propietaria; prefiero quedarme con Cygwin por ahora.

Continuamos entonces:

Descargar e instalar gtkmm for Win32 desde http://www.pcpm.ucl.ac.be/~gustin/win32_ports/. Puede instalarse en el mismo directorio en el que se instaló Glade/GTK para Windows (asumiremos C:\gtk). Este paquete instalará glade--.exe, lo que ya permitirá generar código en C++.
Descargar e instalar Cygwin desde http://www.cygwin.com/. Descargarás inicialmente un ejecutable muy pequeño que te permitirá seleccionar qué paquetes de Cygwin quieres instalar. Cuando llegues a la ventana "Select packages", haz click en el botón "View" para colocarlo en "Full" y selecciona, además de los paqueters que vienen instalados por defecto, los siguientes:

autoconf
automake
binutils
coreutils
gcc-core
gcc-g++
gcc-mingw-core
gcc-mingw-g++
libtool1.5
make

Si todo sale bien, entra en Glade, crea un proyecto, dibuja una ventana con algunos botones y graba el proyecto. No olvides entrar en Options y colocar el lenguaje por defecto en C++ antes de grabar.
Haz click en "Build" para generar el código. Como ya tienes el glade--.exe, no deberías tener mensajes de error importantes. Verás que una ventana de cónsola se abre, se cierra y luego, en el status bar de Glade, aparecerá un mensaje indicando que el código ya fue construido.

Nota: si guardaste el proyecto en una carpeta cuya ruta tenga espacios (por ejemplo, "c:\Documents and settings\Pedro Perez\...") Glade dará un error al compilar: "Error running glade-- to generate the C++ source code." Guárdalo en una carpeta con un nombre sin espacios, como "c:\Proyectos\PedroPerez".
Con eso, generaste en la carpeta src dentro de tu proyecto los archivos .cc y .hh con el esqueleto de tu proyecto, además de otros necesarios para poder compilar. Ahora, viene el paso de la compilación.
Entra en una ventana de Cygwin Bash Shell. Desde allí, haz cd hasta la carpeta de tu proyecto, recordando que allí se usan los slashes como en Unix. Por ejemplo:

cd c:/tesis/proyecto2/
Ahora, ejecuta el comando:

gtkautogen --prefix=/target

Ese comando correrá por tí todos los comandos (glib-gettextize, aclocal, autoheader, automake, autoconf, configure, etc.) necesarios para generar los archivos que permitirán compilar tu proyecto.
Luego, ejecutas el tradicional

make

Y luego:

make install
Si todo sale bien, en la carpeta src dentro de tu proyecto de ejemplo debe estar el ejecutable. Sólo hazle doble click, y podrás verlo correr en todo su esplendor :)

Referencias:

Glade y los problemas que he tenido

2005-08-05T09:36:00.000-04:00

Siendo la interfaz de usuario uno de los elementos principales de este proyecto (pues la facilidad de uso es un elemento clave), fue importante encontrar un ambiente de desarrollo adecuado, con los widgets y elementos de interfaz a los que estamos acostumbrados.

Experiencias previas me habían demostrado cuán importantes son las interfaces de usuario. Por ejemlo, alguna vez programé en el JDK 1.2 y 1.3 usando Swing; lamentablemente sus elementos de interfaz y hasta sus cuadrois de diálogo son tan distintos a los de Windows (o por lo menos lo eran en ese momento) que causaban serios problemas a los usuarios, quienes se veían forzados a aprender de nuevo lo que era el manejo de la interfaz. Tengo entendido que eso ya fue resuelto en las nuevas versiones del JDK de Sun.

Por fortuna, GTK+ reutiliza los cuadros de diálogo del sistema operativo donde se encuentra y da acceso a widgets que, si bien no son 100% iguales a los de Windows, son muy pero muy parecidos evitando así que el usuario tenga que "re-aprender" a usar la interfaz.

GTK+ suministra un programa, llamado Glade, que permite editar interfaces de usuario y generar código en lenguaje C que puede ser compilado bajo GCC o incluso bajo Visual C++ sin ningún problema, generando un cascarón con los eventos y funciones, de tal forma que el programador sólo deba sentarse a llenarlos con las funcionalidades de su aplicación. ¡Un tiro al piso!

Problemas en el paraíso

Lamentablemente, yo debo usar C++, no C. Ello no sólo porque quiero aprovechar las características de un lenguaje orientado a objetos (polimorfismo, herencia, etc.) sino porque deseo utilizar el parser Xerces C++ para trabajar con los archivos XML.

Glade puede generar código en C, C++ o Ada95, pero para generar código en estos dos lenguajes requiere de un programa externo que haga esa misión.

El problema de usar este programa externo, llamado glademm o glade--, es que, bajo Windows, dicho programa no existe. No viene con el paquete de Glade para Windows, y la versión que se puede conseguir en Internet simplemente no funciona (hace crash en tres computadoras distintas donde he hecho la prueba).

Tengo entonces estas opciones:

Usar C, perder todas las características de orientación a objetos y buscar otra forma de parsear archivos XML que no sea usando a Xerces C++
Buscar una forma de resolver el problema con glademm, ya sea compilando yo mismo una versión que funcione bajo Windows, o utilizar la versión bajo Linux, generar el código allí, traerlo a Windows y continuar trabajando.
Utilizar desde mi aplicación las bibliotecas libglademm, que permiten trabajar con el código XML que genera Glade para guardar los archivos y generar la interfazx a partire d

Proyecto: Generador de libros electrónicos software libre, para Linux y Windows, usando GTK+

2005-08-05T02:48:00.000-04:00

La intención inicial de este blog es reseñar los avances del proyecto de una aplicación software libre para la creación, edición y despliegue de libros electrónicos, la cual presentaré como Trabajo Especial de Grado para optar a la Licenciatura en Computación en la Universidad Central de Venezuela (UCV).

La aplicación idealmente cumplirá con estas características:

Cumplirá con una licencia GPL/GNU, cumpliendo con los estatutos generalmente reconocidos para el software libre.
Para ello, utilizará las bibliotecas GTK+ que proveen widgets bajo Windows y Linux/Gnome
Guardará los datos en estándares abiertos como Open eBook, el cual a su vez usa a CSS, XHTML y otros estándares abiertos.
Se programará en C++ o, en caso de ser imposible, se usará C.

El proyecto de tesis comenzó a realizarse en mayo de 2005, pero diversos retrasos ajenos a la tesis y a la universidad hicieron que perdiera varios meses. Finalmente, en agosto logré reorientar mis prioriodades y comenzar de nuevo.