Adlair Cerecedo

Ya me habían dicho, QtC & Qt# no tendrían futuro, pero cómo saberlo?. Visitando el sitio de Mono me encuentro con la muerte de Qt#, así es, Mono en su sitio lo ha publicado dentro de su sección “Dead Toolkits“. Mi perfil sigue activo, desde que renuncié a escribir código para ese proyecto (Abril o Mayo de 2007) no supe más, sólo mails de Marcus Urban sobre referencias a lo nuevo en “Qt# for Mono“. No recuerdo cuál fue mi última aportación y ni que fue lo último que programé, creo que fueron ejemplos de código para la ponencia en el CONSOL 2007, en fin. Alguna vez Federico Mena me dijo que faltaba mucha madurez a Qt#, después me entere (sin argumentos que lo compruebe) que TrollTech quería manipular el proyecto. Hoy el sitio ha sido redireccionado a algo llamado Qyoto que no se qué diablos es pero ahí está y ni hablar, se cierra ese capitulo y a ver cuales siguen.

Bien, ya me despido. Saludos!!!

El FLISOL ha terminado, hoy por la mañana acompañé a Hans y Leo a desayunar en el centro de la ciudad, después cada quien se fue por su rumbo, Leo al DF y Hans a Xalapa. Lo que ahora corresponde es planear con Leo la visita a Tapachula para llevar las compus que se donarán al grupo de desarrollo.

El día de mañana se llevará a cabo el FLISOL 2007 aquí en Poza Rica. Lo chido es que contaremos con la visita de un par de camaradas noruegos, Leo Utskot y Hans Petter quienes participarán con unas charlas.

Leo Utskot y Hans Petter

También en este evento estará Marcos Islas, Eric “Crac” y yo con otras charlas. El evento finalizará pasado mañana con el festival de instalación.

Los esperamos.

Ayer por la noche me llegó mail de una persona pidiendo un ejemplo en Qt# usando Strings, con todo gusto le pongo el siguiente código:

using System;
using Qt;

public class MyWidget : QVBox
{
     QLineEdit lineEdit;
     QLabel label;

     public MyWidget (QWidget parent, String name) : base (parent, name)
     {
           lineEdit = new QLineEdit( this, “lineEdit” );
           label = new QLabel( this, “label” );
           label.SetText(”Default”);

          QObject.Connect( lineEdit, SIGNAL(”textChanged(QString)”),
               label, “SetText(QString)” );
     }

     public MyWidget (QWidget parent) : this (parent, “”) {}
     public MyWidget () : this (null, “”) {}
}

public class Example {

     public static int Main (String[] args)
     {
          QApplication a = new QApplication (args);

          MyWidget w = new MyWidget ();
          a.SetMainWidget (w);
          w.Show ();
          return a.Exec ();
     }
}

Éste es un ejemplo sencillo y muy útil para entender un poco más lo que es el uso de los Widgets de Strings.

Por cierto, mañana salgo para Poza Rica, me da mucha flojera y más porque aún tengo muchas cosas que hacer… Mi vida es un completo desastre… En fin, bye bye!!! :s

Este fin de semana estuvo chido gracias al BarCamp. Leo Utskot, Hans Petter, Gunnar y La Mancha escucharon mi propuesta y al parecer recibiré apoyo. Esta propuesta consiste en formar un club de desarrollo de SL por lo que les pido que si alguien tiene una computadora que no utilize, o una tarjeta o algo envíenle mail a Leo (leo@copyleft.com.mx). Esperamos sus donaciones, gracias.

BarCamp

El primer dia hubieron muchas cosas novedosas para mi, como el Django Framework para desarrollo web mediante Python. Lo bonito fué que comimos Sushi!!!

SUSHI!!!

Y es de Sushi Itto!!!

Para el segundo dia todo fué mejor pués incluso jugamos algo llamado Mafioso, pero como estamos en México Leo lo renombro como Narco. Esta ocasión comimos una deliciosa comida Italiana.

Es muy notorio que yo tenía mucha hambre.

Todos en la espera de la comida.

No podía faltar también que en este evento faltaran las chelas… no no no. Estuvo muy padre, todo mundo conbebiendo y pasándosela chido.

A chupar que el mundo se va a acabar!!!

Hans Petter y yo conbebiendo.

Fernando Magariños “La Mancha”.

Les recomiendo que asistan el próximo año ya que llega gente súper interesante. Pueden ver las fotos aqui.

Ha concluido este maravilloso congreso en la facultad de Ingeniería de la UNAM, todo ha salido bien a excepción del problema que hubo en la conferencia de Javier y Pedro con un fulano que me calló de la patada, pero en fin. Hubieron cosas curiosas como el hecho de que me cambiaran mi nombre debido a que la computadora registradora tenía broncas con los acentos.

Y así me presentaron en mi plática… jejejejeje. :p

Mi taller y mi plática salieron perfectos, conocí nuevos amigos como los de la Tuxteno y algunos camaradas de la Zona RTM.

Marcuz, yo y Gunnar

Marcuz y yo

Bien, me despido porque hay fiesta y mañana inicia el BarCamp pero pueden ver las fotos aqui.

Las conferencias en Mapastepec, Chis. fueron un éxito, aunque debo decir que hubo ciertos problemitas con algunas máquinas durante mi taller. Lo primero que hicimos el Crac y yo fue ir al restaurante del hotel y pedir unas chelitas… jejejejeje. Después de cada jornada de talleres o ponencias nos íbamos a chelear un rato José Luis, Xepix, Neto, el Crac y yo.

Al otro día de la clausura del evento nos llevaron a una playa llamada Zacapulco, es muy bonito, se accesa mediante lancha debido a que hay un estero. Comimos, nos bañamos, bebimos, hicimos desma, etc., muy chingón.

Espero volver pronto, mientras tanto pueden ver las fotos aquí.

El avance potencial en la nueva integración de Qt# para KDE empieza a dar frutos. He modificado y mejorado el sistema de integración entre Qt# y el sistema de configuraciones como Screensavers, Wallpapers, ordenación de íconos y otras cositas básicas. El punto de partida para lograr esto es el nuevo hack del núcleo (Qt.dll) basado en el viejo Aremis (explicado en otro post anterior) obteniendo como resultados una programación pura y libre de bugs (o almenos eso espero).

/*Write by Adlair Cerecedo*/
QtConfigureAllSettings::ConfigureAllSettings (Qt_KDE_PropertySettings *done)
{
          filter = NULL;
          summary_property = QtGetSettings (filter, *active);
          config = QtCommit (done);

          apply_changes = QtAremis_Backend (summary_property, filter, config);
}

El backend de Aremis funciona perfecto, espero terminar de escribir pronto todas las configuraciones, mientras tanto seguiré hackeando en Qt# y el nuevo backend de Aremis.

Ya vieron el angelito?. Ah!, atras también hay otro angelito.

Hay una novedad dentro de la función QCanvas() incluida en Qtcsharp Project, ésta acelerará y mejorará el proceso de dibujo en cualquiera de sus funciones adyacentes:

qt_QCanvas.cpp description:

/****************************************************************
* *
* This library is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Library General Public License as *
* published by the Free Software Foundation; either version 2 of the *
* License, or (at your option) any later version. *
* *
*****************************************************************/

/*

Writted by:

Marcus Urban

Adlair Cerecedo

*/

extern “C” {
#include “qt_QCanvas.h”
}

#include

class QCanvasBridge : public QCanvas
{
public:
QCanvasBridge(QObject* parent, const char* name) : QCanvas(parent, name) {}
QCanvasBridge(int w, int h) : QCanvas(w, h) {}
QCanvasBridge(QPixmap p, int h, int v, int tilewidth, int tileheight) : QCanvas(p, h, v, tilewidth, tileheight) {}
~QCanvasBridge() {}
void protected_drawBackground(QPainter& arg1, const QRect& area) {
QCanvas::drawBackground(arg1, area);
return;
}
void qt_QCanvas_removeAnimation( qt_QCanvas* instPointer,qt_QCanvasItem* arg1){
((QCanvasBridge*)instPointer)->removeAnimation((QCanvasItem*)arg1);
return;
}
void qt_QCanvas_setAdvancePeriod( qt_QCanvas* instPointer,int ms){
((QCanvasBridge*)instPointer)->setAdvancePeriod((int)ms);
return;
}
void qt_QCanvas_setUpdatePeriod( qt_QCanvas* instPointer,int ms){
((QCanvasBridge*)instPointer)->setUpdatePeriod((int)ms);
return;
}
void qt_QCanvas_setDoubleBuffering( qt_QCanvas* instPointer,int y){
((QCanvasBridge*)instPointer)->setDoubleBuffering((bool)y);
return;
}
void qt_QCanvas_advance( qt_QCanvas* instPointer){
((QCanvasBridge*)instPointer)->advance();
return;
}

void protected_drawForeground(QPainter& arg1, const QRect& area) {
QCanvas::drawForeground(arg1, area);
return;
}
void childEvent(QChildEvent* arg1) {
if (Qt_EventDelegate == 0L || !(*Qt_EventDelegate)(this, “childEvent”, arg1, “QChildEvent”)) {
QObject::childEvent(arg1);
}
return;
}
void customEvent(QCustomEvent* arg1) {
if (Qt_EventDelegate == 0L || !(*Qt_EventDelegate)(this, “customEvent”, arg1, “QCustomEvent”)) {
QObject::customEvent(arg1);
}
return;
}
void timerEvent(QTimerEvent* arg1) {
if (Qt_EventDelegate == 0L || !(*Qt_EventDelegate)(this, “timerEvent”, arg1, “QTimerEvent”)) {
QObject::timerEvent(arg1);
}
return;
}
};
qt_QCanvas * qt_new_QCanvas(qt_QObject * parent, char* name){
return (qt_QCanvas *) new QCanvasBridge((QObject*)parent, (char*)name);
}
qt_QCanvas * qt_new_QCanvas1(int w, int h){
return (qt_QCanvas *) new QCanvasBridge((int)w, (int)h);
}
qt_QCanvas * qt_new_QCanvas2(qt_QPixmap * p, int h, int v, int tilewidth, int tileheight){
return (qt_QCanvas *) new QCanvasBridge((QPixmap)* (QPixmap*)p, (int)h, (int)v, (int)tilewidth, (int)tileheight);
}
void qt_del_QCanvas( qt_QCanvas* p ){
delete (QCanvasBridge*) p;
}
void qt_QCanvas_setTiles( qt_QCanvas* instPointer,qt_QPixmap * tiles, int h, int v, int tilewidth, int tileheight){
((QCanvasBridge*)instPointer)->setTiles((QPixmap)* (QPixmap*)tiles, (int)h, (int)v, (int)tilewidth, (int)tileheight);
return;
}
void qt_QCanvas_setBackgroundPixmap( qt_QCanvas* instPointer,qt_QPixmap * p){
((QCanvasBridge*)instPointer)->setBackgroundPixmap((QPixmap&)* (QPixmap*)p);
return;
}
qt_QPixmap * qt_QCanvas_backgroundPixmap( qt_QCanvas* instPointer){
return (qt_QPixmap *)new QPixmap(((QCanvasBridge*)instPointer)->backgroundPixmap());
}
void qt_QCanvas_setBackgroundColor( qt_QCanvas* instPointer,qt_QColor * c){
((QCanvasBridge*)instPointer)->setBackgroundColor((QColor&)* (QColor*)c);
return;
}
qt_QColor * qt_QCanvas_backgroundColor( qt_QCanvas* instPointer){
return (qt_QColor *)new QColor(((QCanvasBridge*)instPointer)->backgroundColor());
}
void qt_QCanvas_setTile( qt_QCanvas* instPointer,int x, int y, int tilenum){
((QCanvasBridge*)instPointer)->setTile((int)x, (int)y, (int)tilenum);
return;
}
int qt_QCanvas_tile( qt_QCanvas* instPointer,int x, int y){
return (int) ((QCanvasBridge*)instPointer)->tile((int)x, (int)y);
}
int qt_QCanvas_tilesHorizontally( qt_QCanvas* instPointer){
return (int) ((QCanvasBridge*)instPointer)->tilesHorizontally();
}
int qt_QCanvas_tilesVertically( qt_QCanvas* instPointer){
return (int) ((QCanvasBridge*)instPointer)->tilesVertically();
}
int qt_QCanvas_tileWidth( qt_QCanvas* instPointer){
return (int) ((QCanvasBridge*)instPointer)->tileWidth();
}
int qt_QCanvas_tileHeight( qt_QCanvas* instPointer){
return (int) ((QCanvasBridge*)instPointer)->tileHeight();
}
void qt_QCanvas_resize( qt_QCanvas* instPointer,int width, int height){
((QCanvasBridge*)instPointer)->resize((int)width, (int)height);
return;
}
int qt_QCanvas_width( qt_QCanvas* instPointer){
return (int) ((QCanvasBridge*)instPointer)->width();
}
int qt_QCanvas_height( qt_QCanvas* instPointer){
return (int) ((QCanvasBridge*)instPointer)->height();
}
qt_QSize * qt_QCanvas_size( qt_QCanvas* instPointer){
QSize _s= ((QCanvasBridge*)instPointer)->size();
return (qt_QSize *)new QSize(_s.width(),_s.height());
}
qt_QRect* qt_QCanvas_rect( qt_QCanvas* instPointer){
QRect _r= ((QCanvasBridge*)instPointer)->rect();
return (qt_QRect*)new QRect(_r.left(),_r.top(),_r.width(),_r.height());
}
int qt_QCanvas_onCanvas( qt_QCanvas* instPointer,int x, int y){
return (int) ((QCanvasBridge*)instPointer)->onCanvas((int)x, (int)y);
}
int qt_QCanvas_onCanvas1( qt_QCanvas* instPointer,qt_QPoint* p){
return (int) ((QCanvasBridge*)instPointer)->onCanvas((QPoint&)* (QPoint*)p);
}
int qt_QCanvas_validChunk( qt_QCanvas* instPointer,int x, int y){
return (int) ((QCanvasBridge*)instPointer)->validChunk((int)x, (int)y);
}
int qt_QCanvas_validChunk1( qt_QCanvas* instPointer,qt_QPoint* p){
return (int) ((QCanvasBridge*)instPointer)->validChunk((QPoint&)* (QPoint*)p);
}
int qt_QCanvas_chunkSize( qt_QCanvas* instPointer){
return (int) ((QCanvasBridge*)instPointer)->chunkSize();
}
void qt_QCanvas_retune( qt_QCanvas* instPointer,int chunksize, int maxclusters){
((QCanvasBridge*)instPointer)->retune((int)chunksize, (int)maxclusters);
return;
}
int qt_QCanvas_sameChunk( qt_QCanvas* instPointer,int x1, int y1, int x2, int y2){
return (int) ((QCanvasBridge*)instPointer)->sameChunk((int)x1, (int)y1, (int)x2, (int)y2);
}
void qt_QCanvas_setChangedChunk( qt_QCanvas* instPointer,int i, int j){
((QCanvasBridge*)instPointer)->setChangedChunk((int)i, (int)j);
return;
}
void qt_QCanvas_setChangedChunkContaining( qt_QCanvas* instPointer,int x, int y){
((QCanvasBridge*)instPointer)->setChangedChunkContaining((int)x, (int)y);
return;
}
void qt_QCanvas_setAllChanged( qt_QCanvas* instPointer){
((QCanvasBridge*)instPointer)->setAllChanged();
return;
}
void qt_QCanvas_setChanged( qt_QCanvas* instPointer,qt_QRect* area){
((QCanvasBridge*)instPointer)->setChanged((QRect&)* (QRect*)area);
return;
}
void qt_QCanvas_setUnchanged( qt_QCanvas* instPointer,qt_QRect* area){
((QCanvasBridge*)instPointer)->setUnchanged((QRect&)* (QRect*)area);
return;
}
void qt_QCanvas_addItemToChunk( qt_QCanvas* instPointer,qt_QCanvasItem* arg1, int i, int j){
((QCanvasBridge*)instPointer)->addItemToChunk((QCanvasItem*)arg1, (int)i, (int)j);
return;
}
void qt_QCanvas_removeItemFromChunk( qt_QCanvas* instPointer,qt_QCanvasItem* arg1, int i, int j){
((QCanvasBridge*)instPointer)->removeItemFromChunk((QCanvasItem*)arg1, (int)i, (int)j);
return;
}
void qt_QCanvas_addItemToChunkContaining( qt_QCanvas* instPointer,qt_QCanvasItem* arg1, int x, int y){
((QCanvasBridge*)instPointer)->addItemToChunkContaining((QCanvasItem*)arg1, (int)x, (int)y);
return;
}
void qt_QCanvas_removeItemFromChunkContaining( qt_QCanvas* instPointer,qt_QCanvasItem* arg1, int x, int y){
((QCanvasBridge*)instPointer)->removeItemFromChunkContaining((QCanvasItem*)arg1, (int)x, (int)y);
return;
}
qt_QCanvasItemList* qt_QCanvas_allItems( qt_QCanvas* instPointer){
return (qt_QCanvasItemList*)new QCanvasItemList(((QCanvasBridge*)instPointer)->allItems());
}
qt_QCanvasItemList* qt_QCanvas_collisions( qt_QCanvas* instPointer,qt_QPoint* arg1){
return (qt_QCanvasItemList*)new QCanvasItemList(((QCanvasBridge*)instPointer)->collisions((QPoint&)* (QPoint*)arg1));
}
qt_QCanvasItemList* qt_QCanvas_collisions1( qt_QCanvas* instPointer,qt_QRect* arg1){
return (qt_QCanvasItemList*)new QCanvasItemList(((QCanvasBridge*)instPointer)->collisions((QRect&)* (QRect*)arg1));
}
qt_QCanvasItemList* qt_QCanvas_collisions2( qt_QCanvas* instPointer,qt_QPointArray* pa, qt_QCanvasItem* item, int exact){
return (qt_QCanvasItemList*)new QCanvasItemList(((QCanvasBridge*)instPointer)->collisions((QPointArray&)* (QPointArray*)pa, (QCanvasItem*)item, (bool)exact));
}
void qt_QCanvas_drawArea( qt_QCanvas* instPointer,qt_QRect* arg1, qt_QPainter * p, int double_buffer){
((QCanvasBridge*)instPointer)->drawArea((QRect&)* (QRect*)arg1, (QPainter*)p, (bool)double_buffer);
return;
}
void qt_QCanvas_addView( qt_QCanvas* instPointer,qt_QCanvasView* arg1){
((QCanvasBridge*)instPointer)->addView((QCanvasView*)arg1);
return;
}
void qt_QCanvas_removeView( qt_QCanvas* instPointer,qt_QCanvasView* arg1){
((QCanvasBridge*)instPointer)->removeView((QCanvasView*)arg1);
return;
}
void qt_QCanvas_drawCanvasArea( qt_QCanvas* instPointer,qt_QRect* arg1, qt_QPainter * p, int double_buffer){
((QCanvasBridge*)instPointer)->drawCanvasArea((QRect&)* (QRect*)arg1, (QPainter*)p, (bool)double_buffer);
return;
}
void qt_QCanvas_drawViewArea( qt_QCanvas* instPointer,qt_QCanvasView* view, qt_QPainter * p, qt_QRect* r, int dbuf){
((QCanvasBridge*)instPointer)->drawViewArea((QCanvasView*)view, (QPainter*)p, (QRect&)* (QRect*)r, (bool)dbuf);
return;
}
void qt_QCanvas_addItem( qt_QCanvas* instPointer,qt_QCanvasItem* arg1){
((QCanvasBridge*)instPointer)->addItem((QCanvasItem*)arg1);
return;
}
void qt_QCanvas_addAnimation( qt_QCanvas* instPointer,qt_QCanvasItem* arg1){
((QCanvasBridge*)instPointer)->addAnimation((QCanvasItem*)arg1);
return;
}
void qt_QCanvas_removeItem( qt_QCanvas* instPointer,qt_QCanvasItem* arg1){
((QCanvasBridge*)instPointer)->removeItem((QCanvasItem*)arg1);
return;
}

void qt_QCanvas_update( qt_QCanvas* instPointer){
((QCanvasBridge*)instPointer)->update();
return;
}
void qt_QCanvas_drawBackground( qt_QCanvas* instPointer,qt_QPainter* arg1, qt_QRect* area){
((QCanvasBridge*)instPointer)->protected_drawBackground((QPainter&)* (QPainter*)arg1, (QRect&)* (QRect*)area);
return;
}
void qt_QCanvas_drawForeground( qt_QCanvas* instPointer,qt_QPainter* arg1, qt_QRect* area){
((QCanvasBridge*)instPointer)->protected_drawForeground((QPainter&)* (QPainter*)arg1, (QRect&)* (QRect*)area);
return;
}

Disponible, no sé cuando. :-s

Dudas con gusto dejen comentario.

Bueno queridos amigos me despido porque habrá una fiesta mañana en el Tec, es la titulación de mi amiga Yadira. Bytes!!!

Al fin, a descansar del tan ajetreado fin de semana, muy buena la parranda. Todo inició el día Viernes con mi brother Isidro y su novia la comadre Aurora, nos fuimos de rol y mas tarde aterrizamos con el famosísimo Abel (jejejeje); el Sábado fue similar solo que en esta ocasión a las 3 pm fui al estadio Olímpico a ver el partido de fútbol entre los Ocelotes de la UNACH contra Cancún, duelo de damnificados en la lucha por una despensa (que cruel), después del partido me dirigí a ver lo que sería la futura oficina de CIEDS Technologies, más tarde fui a casa de Isidro y nos dirigimos a secuestrar a un amigo llamado Rudy (es un desmadre ese wey); ya en Domingo salí por la tarde y solo escuche la dulce voz de mi madre diciendo: "Vuelves a llegar tarde y le pongo seguro a la puerta, es más, dame tus llaves!!!", siempre las mamis tan dulces y cariñosas.

Por cierto, he recibido algunos mails preguntándome como compilar en Mono con Qt#, el proceso de compilación es muy sencilla, he aquí la solución:

[adlair@xennia QtProgs]$ mcs -r Qt myprogram.cs

Esto producirá myprogram.exe. Si tu tienes colocado Qt.dll en otra carpeta, tu deberás intentar como "mcs -r /ruta/completa/a/Qt.dll myprogram.cs", por ejemplo:

[adlair@xennia adlair]$ mcs -r /home/adlair/qt/QtProgs/Qt.dll myprogram.cs

Para ejecutar el programa ya compilado (myprogram.exe) simplemente se escribe la siguiente instrucción:

[adlair@xennia adlair]$ mono myprogram.exe

Espero que las dudas hayan sido resueltas, cualquier duda dejen mensaje en este Post

He recopilado toda la información referente a Qt# y como lo prometido es deuda, he aquí toda la información para todos aquellos que quieran colaborar con nosotros y unirse al Qt-Developers-Team.

 De Marcus <mathpup@mylinuxisp.com> 

 Enviado  Miércoles, Marzo 10, 2004 11:00 pm

 Para  Adlair <adlair.cerecedo@prodigy.net.mx>
 Asunto  Qt# info

Marcus Urban

De Marcus <mathpup@mylinuxisp.com>

Fecha Wed, 10 Mar 2004 20:46:50 +0000
Para "Desmond, Colin" <Colin.Desmond@logicacmg.com>

Asunto Re: Qt#

On Wednesday 10 March 2004 4:01 pm, you wrote:

> I finally found time to get the 0.7.1 version of Qt# working last night,
> are there any nice simple problems you’d like me to look at as a way of a
> gentle introduction to the code?

Basically, things are at a transition point. We have the “old” or “current” —
I’m not sure what to call it. It’s the stuff that’s in QTSHARP-0_7_1_BRANCH.
I branched that off from QTSHARP_0_7_BRANCH because I wasn’t sure if I want
to keep the qmake-based build system. The way that I rigged it to build C#
code isn’t terribly elegant to me. (I’m thinking about writing a csant-like
build system myself.)

In any case, that version relies on QtC, which has not been maintained.
Unfortuantely, the Kalyptus-generated QtC source files still require much
hand-editing to be compilable, which is probably why QtC is incomplete and
has not been kept up.

Also, the core of Qt#, which is Qt.dll, has its source files built from XML
using a module for Kalyptus. Unfortunately, Adam (who started Qt#)
lost/deleted/erased the only copy of that module.

Back when there were several of us working on this, I was working on a
hand-written parser for C++ headers while Adam and Nick were working on a
binding generator called BINGE. Since then I’ve realized that it’s too darned
hard to parse C++ and produce XML, so I’ve switched over to using Doxygen.

I’m not sure that I want to use BINGE because the code seems to be something
of a pain to deal with. So I’ve been working on my own solutions. Let me tidy
up the code a little bit, and then I’ll show it to you. I’m afraid it’ll be a
little confusing and overwhelming right now.

Also I’m going to forward a couple emails to you, but there are some
corrections that should be made. There is also a mailing list, which isn’t
very active: qtcsharp-list@lists.sourceforge.net

> Also I think the INSTALL file instructions need correcting, it talks about
> configure ; make; make install, where as I think you need to do qmake ;
> make ; make install.

I committed a change to INSTALL in CVS recently that corrects that issue.

I’m thinking about releases a new version very soon. The 0.7 version and the
0.7.1_BRANCH in CVS are not much different except that the build system has
been modified not to require Pnet’s csant, and the directories have been
restructured.

By the way, Qt# can be built with Pnet version 0.6.2, which is the latest
official release, but the XML classes in their CVS have been broken for quite
a while since the last release. I’m told that they plan to release their next
version soon and without fixing their XML classes.

The main things that have changed since these messages is that I’m not sure
about salvaging BINGE’s code. Also, Wade is working on updating the website.

I’ll send you some more info later today or tomorow.

Marcus
—– Mensaje original —–
De Marcus
Fecha Tue, 20 Jan 2004 22:58:06 -0600
Para qtcsharp-list@lists.sourceforge.net
Asunto Qt# C interface library; movement to Doxygen

I have done some work, research, and documenting lately. These might not sound
terribly exciting because the product isn’t usable code, but hopefully they
will contribute to that.

C Interface Library

My main work has been on an extensible replacement for QtC. QtC is generated
by Kalyptus, which is written in Perl, and I have no desire or aptitute for
Perl. Furthermore, the Kalyptus-generated headers are not directly compilable
by GCC but rather require a great amount of hand-tuning. (Presumably this
could be done by another Perl script.) Also, many functions present in Qt#
(in as DllImport’ed extern methods) are missing from QtC, which creates a
large number of annoying warnings.

The replacement C library will use the same XML description of Qt as the C#
code-generator. The C generator (which is currently called CGen for lack of a
creative name) can correctly generate compilable C code for the QString and
QPushButton classes.

Why a C Glue/Interface Library is Needed on GCC Platforms

I have concluded that some sort of interface between C# and C++ is necessary.
I feel compelled to write it to justify to myself and others why we cannot
simply dispense with the cumbersome concept of an intermediate layer.

If something similar VS.NET’s Managed Extensions for C++ existed for GCC,
a single layer might be written. For GCC, this would require a front-end for
managed-extensions and a back-end capable of emitting ECMA assemblies
containing managed and unmanaged code. Because GCC would “know about'’ Qt
classes (since it is a C++ compiler) and because it also knows how to create
managed classes, many aspects of development would be simplified.

Given the current situation, there at least 4 reasons why an intermediate
layer is needed. First, there is no way to create a new instance of a C++
object from outside C++ unless the C++ library provides an appropriate
function. There is no obvious way to determine how much memory to allocate
for a given C++ object, so even if it were possible to call a C++ constructor
directly to initialize the object, allocating the object in the first place
seems impossible.

Second, C++ compilers use name-mangling to avoid duplication of symbols when
several classes define the same method and when overloaded methods are used.
This mangling is platform dependent. It is possible to use system-specific
utilities to produce a list of mangled and unmanagled names and then match
them up to create a conversion table. So this is more of an annoyance than an
an outright dead-end.

Third, when optimization is specified, C++ compilers frequently inline any
methods those bodies are defined within the class scope (and possibly other
methods as well). Moreover, if every invocation of a method is inlined, some
compilers do not by default emit an out-of-line copy for the method.

Fourth, in several cases, it is desirable to intercept C++ virtual methods and
possibly redirect them to managed code. (This is how Qt# “overrides'’ of
C++-defined methods could be implemented.) Without an intermediate layout,
the only option would be platform-dependent hacking of virtual-method tables.

Movement to Doxygen

A little over a year ago, I wrote parser to handle the minimal amount of C++
needed to cover Qt’s header files. I had examined several existing tools and
found them unsuitable for various reasons. After much gnushing of teeth and
attempting at extending the parser to handle enough of C++ for all Qt’s
headers, I finally re-examined Doxygen. Doxygen is capable of outputting a
variety of formats, including XML. Although its XML format is substantially
different from the current format that my original parser created, being
freed from the burden of having to continue to develop my own little parser
has led me to justify changing formats.

I’m in the process of changing the code for my C interface generator to handle
Doxygen’s format. This will take a bit of time as I adjust but I believe that
this is the best way to go for now.

—————————————————————————————–
The SF.Net email is sponsored by EclipseCon 2004
Premiere Conference on Open Tools Development and Integration
See the breadth of Eclipse activity. February 3-5 in Anaheim, CA.
http://www.eclipsecon.org/osdn
______________________________________________________________
Qtcsharp-list mailing list
Qtcsharp-list@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/qtcsharp-list
—– Mensaje original —–
De Marcus Fecha Tue, 20 Jan 2004 23:19:20 -0600
Para qtcsharp-list@lists.sourceforge.net
Asunto Qt# Help Wanted

I would like to get some help with Qt#. I realize that it is hard to attract
people when there is so little visible forward movement, but there are some
things that could be done to help. Remember that there is a semi-stable
version of Qt# available for download at http://qtcsharp.sourceforge.net
and that it includes examples. I am working on creating a new and better
version of Qt#, but the version available for download is usable.

Some tasks, which vary widely:

1. Update the FAQ on the website

2. Update the website itself to give it more organized appearance. Obviously,
opinions on aesthetics will vary. I believe that the “menu” on the left is
cluttered with too many choices. Nested menu choices or a separate
documentation page might help. Some pretty graphics would also be nice.

3. Write a guide on Qt# for Qt/C++ programmers. The basic idea is the explain
the differences, including capitalization patterns, QString versus
System.String (C# “string”), unicode, C++ 0 versus C# null, enumerations,
namespaces, and so forth. As I recall, the PyGTK would be a good place to
look for hints on this.

4. Continue development on Nick and Adam’s BINGE (Binding Generator), which
generates C# bindings from an XML description of the API. The source code is
in the CVS HEAD branch. Since I’m moving the C Generator to Doxygen, BINGE
should probably move to Doxygen as well. If analyzing, improving, and
rewriting BINGE is too daunting a task, an alternative would be to develop an
original tool to generate C# code. This took could share code with the C
Generator.

5. Write applications, tests, examples, bug reports, comments, or questions.
There’s no need for much formality at this stage. Just post to the mailing
list or email me.

Feel free to join #qtsharp on irc.freenode.net

Marcus

—————————————————————————————–
The SF.Net email is sponsored by EclipseCon 2004
Premiere Conference on Open Tools Development and Integration
See the breadth of Eclipse activity. February 3-5 in Anaheim, CA.
http://www.eclipsecon.org/osdn
______________________________________________________________
Qtcsharp-list mailing list
Qtcsharp-list@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/qtcsharp-list
—– Mensaje original —–
De Marcus Fecha Sat, 21 Feb 2004 01:49:30 -0500
Para qtcsharp-list@lists.sourceforge.net
Asunto Qt#, Portable.NET (aka Pnet), Build System

Just to let people know, the latest versions of Portable.NET (Pnet) are not
capable of producing a working Qt#. The problem lies with bugs in Pnet’s XML
modules. The solution is to switch to Mono: http://go-mono.com

I have also removed the dependency on Pnet’s csant build tool for Qt#.

If you have an earlier release of Pnet with non-broken XML, and you want to
build Qt#, you can still do so by running qmake CSC=cscc CLI=ilrun
and then running make.

—————————————————————————————–
SF.Net is sponsored by: Speed Start Your Linux Apps Now.
Build and deploy apps & Web services for Linux with
a free DVD software kit from IBM. Click Now!
http://ads.osdn.com/?ad_id=1356&alloc_id=3438&op=click
______________________________________________________________
Qtcsharp-list mailing list
Qtcsharp-list@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/qtcsharp-list