gtk_object bad signal

["dbasald libero it" <dbasald libero it>]

hi all

I'm new of GTK+ pogramming. I'm tring to develp an application in linux written in C with GTK 2.8 libraries.
This app is interfaced with a database, reads data from it and create a GUI.
I made a GTK object for detection of database UPDATEs, I mean: when the DBmanager receives an UPDATE command from a connection it starts a RULE that emits a signal. My object has a p_thread looping over a SELECT that
checks for DBmanager signals. After detection of DB signal emission my object emits an own gtk-signal (named disp-signal).
This last gtk-signal is connected to a function for GUI updating by a g_signal_connect().
Same function is also called by one other g_signal_connect() activted by a button_press_event.
This two connections are because the user can change values shown in GUI but s/he is allowed to comeback to
batabase settings. If the user saves some new values all other clients programs have to update their GUI.
The problem is here: if I click te button the GUI is updated correctly but when the "updateGUIfunction" is
called by my object signal the program crashes after a few updates. The crash comes with an Xlib error
shown into stderr. After that the program objects not updated appears to work fine but all the widget areas
destroyed and newed comes hidden. Sometimes I get a GTK_DRAWABLE failed error like following:
(prova_gnome2:10237): Gdk-CRITICAL **: gdk_drawable_get_size: assertion `GDK_IS_DRAWABLE (drawable)' failed

(prova_gnome2:10237): Gdk-CRITICAL **: gdk_window_invalidate_rect: assertion `window != NULL' failed

It could be due to my signal interface not well initialized: it don't return user_data like a gtk-button
(I don't know why, I followed on-line gtk examples) but I tried to use the gtk button signal included in child field of my object with same results.

Please help me!

thanks,
Daniele B.

The following code is my object for database signal detection and usage into the program:

/***************************************************************************
 *            pgmonitorr.h
 ****************************************************************************/

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif


#ifndef __PGMONITORR_H__
#define __PGMONITORR_H__

#include <gdk/gdk.h>
#include "libpq-fe.h"

G_BEGIN_DECLS

#define PGMONITORR_TYPE            (pgmonitorr_get_type ())
#define PGMONITORR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), PGMONITORR_TYPE, Pgmonitorr))
#define PGMONITORR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), PGMONITORR_TYPE, PgmonitorrClass))
#define IS_PGMONITORR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PGMONITORR_TYPE))
#define IS_PGMONITORR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PGMONITORR_TYPE))
#define PGMONITOR_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), PGMONITORR, PgmonitorrClass))


typedef struct _Pgmonitorr      Pgmonitorr;
typedef struct _PgmonitorrClass PgmonitorrClass;

struct _Pgmonitorr
{
	GtkBin parent;
	GtkWidget *child;

	gchar conninfo[500];
	gchar segnale[50];

	PGconn     *async_conn;
	pthread_t  monitor_t;
	//GThread *monitor_t;
};

struct _PgmonitorrClass
{
	GtkBinClass parent_class;

	void (* pgmonitorr) (Pgmonitorr *pgm);
};

GType          pgmonitorr_get_type        (void);
GtkWidget*     pgmonitorr_new             (char * conninfo, char * segnale);
void    pgmonitorr_clear           (Pgmonitorr *pgm);

G_END_DECLS

#endif /* __PGMONITORR_H__ */


/***************************************************************************
 *            pgmonitorr.c
 ****************************************************************************/

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <config.h>
#include <gnome.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <gtk/gtksignal.h>
#include <gtk/gtkobject.h>
#include <pthread.h>
#include <string.h>
#include "pgmonitorr.h"
#include "libpq-fe.h" // libreria di intergaccia col postgres

enum {
  DISP_SIGNAL,
  LAST_SIGNAL
};
static guint pgmonitorr_signals[LAST_SIGNAL] = { 0 };

static void pgmonitorr_class_init           (PgmonitorrClass *klass);
static void pgmonitorr_init                 (Pgmonitorr      *pgm);
static void enable_pgmonitor		    (Pgmonitorr      *pgm);

GType
pgmonitorr_get_type (void)
{

static GtkType pgm_type = 0;
  if (!pgm_type)
    {
      static const GtkTypeInfo pgm_info =
      {
        "PGmonitorr",
        sizeof (Pgmonitorr),
        sizeof (PgmonitorrClass),
        (GtkClassInitFunc) pgmonitorr_class_init,
        (GtkObjectInitFunc) pgmonitorr_init,
        /* reserved_1 */ NULL,
        /* reserved_2 */ NULL,
        (GtkClassInitFunc) NULL,
      };
	  pgm_type = gtk_type_unique (GTK_TYPE_BIN, &pgm_info);

    }
  fprintf (stderr,"pgmonitorr: gettype\n");
  return pgm_type;
}

static void
pgmonitorr_class_init (PgmonitorrClass *class)
{
	 GtkObjectClass *object_class;
     	object_class = (GtkObjectClass*) class;

	pgmonitorr_signals[DISP_SIGNAL] = g_signal_new ("disp_signal",
                                         G_TYPE_FROM_CLASS (class),
                                         G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
                                         G_STRUCT_OFFSET (PgmonitorrClass, pgmonitorr),
                                         NULL,
                                         NULL,
										 g_cclosure_marshal_VOID__VOID,
										 /*gtk_signal_default_marshaller,*/
		    							 GTK_TYPE_NONE, 0);

	fprintf (stderr,"pgmonitorr: class_init\n");
}

static void
pgmonitorr_init (Pgmonitorr *pgm)
{
	pgm->child = NULL;
	g_snprintf (pgm->conninfo,500, "%s","");
	g_snprintf (pgm->segnale,50, "%s","");
	fprintf (stderr, "pgmonitorr: init\n");
}


GtkWidget*
pgmonitorr_new (char * rconninfo, char * rsegnale)
{
	Pgmonitorr * pgm = g_object_new (pgmonitorr_get_type (), NULL);
	pgm->child = GTK_WIDGET(gtk_button_new());
	gtk_container_add(GTK_CONTAINER(pgm),GTK_WIDGET(pgm->child));
	g_snprintf (pgm->conninfo, 500, "%s",rconninfo);
	g_snprintf (pgm->segnale, 50, "%s",rsegnale);
	pthread_create (&(pgm->monitor_t), NULL, (gpointer)enable_pgmonitor, (gpointer)pgm);
	fprintf (stderr,"pgmonitorr: new OK!\n");
  return GTK_WIDGET (pgm);
}

void
pgmonitorr_clear (Pgmonitorr *pgm)
{
	printf ("eseguo chiudi_conn Pgmonitor2\n");
	pthread_cancel(pgm->monitor_t);
	pthread_join (pgm->monitor_t,0);
	PQfinish(pgm->async_conn);
}

static void enable_pgmonitor(Pgmonitorr *pgm)
{
	int      sock;
    	fd_set   input_mask;
	gchar	 nome[30];
  	PGresult   *res;
  	PGnotify   *notify;
	gchar comando[50];

	fprintf (stderr, "pgmonitorr: pthread 1 \n");
	pgm->async_conn = PQconnectdb(pgm->conninfo);
	g_snprintf (comando,50, "LISTEN %s;", pgm->segnale);
	res = PQexec(pgm->async_conn, comando);
	if (PQresultStatus(res) != PGRES_COMMAND_OK)
        {
                fprintf(stderr, "LISTEN command failed: %s", PQerrorMessage(pgm->async_conn));
                PQclear(res);
		PQfinish (pgm->async_conn);
		exit (1);
        }
	PQclear(res);

	fprintf (stderr, "pgmonitorr: pthread 2 \n");

	sock = PQsocket(pgm->async_conn);
 	for (;;)
	{
		fprintf (stderr,"for pgmonitor enable\n");
		FD_ZERO(&input_mask);
    		FD_SET(sock, &input_mask);
        	if (sock < 0)
		{
			fprintf (stderr, "socket error\n");
        	break; // shouldn't happen
		}
		if (select(sock + 1, &input_mask, NULL, NULL, NULL) < 0)
        {
        	fprintf(stderr, "select() failed: %s\n", strerror(errno));
		PQfinish (pgm->async_conn);
        }
        // Now check for input
        PQconsumeInput(pgm->async_conn);
        while ((notify = PQnotifies(pgm->async_conn)) != NULL)
        	{
			g_snprintf (nome,30, "%s", notify->relname);
			fprintf(stderr,"ASYNC NOTIFY of '%s' received from backend pid %d\n",nome, notify->be_pid);
			PQfreemem(notify);
			g_signal_emit (pgm,pgmonitorr_signals[DISP_SIGNAL], 0);
        	}
	}
	fprintf (stderr, "errore pgmonitorr\n");
	pgmonitorr_clear (pgm);
}

/************************************************
*callback.c
***********************/
GtkWidget *monitor_disp=NULL;

	monitor_disp = pgmonitorr_new(conninfo->str, "disponibile");
	gtk_widget_set_name(monitor_disp,"monitor_disp");
	gtk_box_pack_start(GTK_BOX (hbox_generale1),monitor_disp,FALSE,FALSE,0);

	g_signal_connect(G_OBJECT(annulla_button),"button_press_event",
					G_CALLBACK(ins_piatti_modifica_listino), (int*)id_rep);

	g_signal_connect(G_OBJECT(monitor_disp), "disp_signal",
					G_CALLBACK(aux_ins_piatti_modifica_listino), id_rep);


void aux_ins_piatti_modifica_listino (GtkWidget *elemento, int id_rep)
{
	ins_piatti_modifica_listino(elemento,NULL,id_rep);
}

void ins_piatti_modifica_listino executes some lookups, destroy a part of gui and remake it (gtk_vbox_new() ... gtk_spinbutton_new ... gtk_entry_new ...)