void dump_ole(MdbTableDef *table, char *colname, char *sargname)
{
char ole_data[200000];
int len;
MdbSarg sarg;
char *sargcol, *sargop, *sargval;
mdb_bind_column_by_name(table, colname, ole_data, &len);
if (sargname) {
sargcol = strtok(sargname," ");
sargop = strtok(NULL," ");
sargval = strtok(NULL," ");
printf("col %s op %s val %s\n",sargcol,sargop,sargval);
sarg.op = MDB_EQUAL; /* only support = for now, sorry */
strcpy(sarg.value.s, sargval);
mdb_add_sarg_by_name(table, sargcol, &sarg);
}
mdb_rewind_table(table);
while (mdb_fetch_row(table)) {
mdb_buffer_dump(ole_data, 0, len);
printf("---\n");
}
}
void read_to_row(MdbTableDef *table, char *sargname)
{
static MdbSargNode sarg;
char *sargcol, *sargop, *sargval;
unsigned int i;
MdbColumn *col;
if (sargname) {
sargcol = strtok(sargname," ");
for (i=0;i<table->num_cols;i++) {
col=g_ptr_array_index(table->columns,i);
if (!g_ascii_strcasecmp(col->name, (char *)sargcol)) {
sarg.col = col;
break;
}
}
sargop = strtok(NULL," ");
sargval = strtok(NULL," ");
printf("col %s op %s val %s\n",sargcol,sargop,sargval);
sarg.op = MDB_EQUAL; /* only support = for now, sorry */
sarg.value.i = atoi(sargval);
table->sarg_tree = &sarg;
// mdb_add_sarg_by_name(table, sargcol, &sarg);
}
mdb_rewind_table(table);
while (mdb_fetch_row(table)) {
printf("row found at page %d row %d\n",
table->cur_phys_pg, table->cur_row);
return;
}
}
GPtrArray *mdb_read_catalog (MdbHandle *mdb, int objtype)
{
MdbCatalogEntry *entry, msysobj;
MdbTableDef *table;
char obj_id[256];
char obj_name[256];
char obj_type[256];
char obj_flags[256];
int type;
if (!mdb) return NULL;
if (mdb->catalog) mdb_free_catalog(mdb);
mdb->catalog = g_ptr_array_new();
mdb->num_catalog = 0;
/* dummy up a catalog entry so we may read the table def */
memset(&msysobj, 0, sizeof(MdbCatalogEntry));
msysobj.mdb = mdb;
msysobj.object_type = MDB_TABLE;
msysobj.table_pg = 2;
strcpy(msysobj.object_name, "MSysObjects");
/* mdb_table_dump(&msysobj); */
table = mdb_read_table(&msysobj);
if (!table) return NULL;
mdb_read_columns(table);
mdb_bind_column_by_name(table, "Id", obj_id, NULL);
mdb_bind_column_by_name(table, "Name", obj_name, NULL);
mdb_bind_column_by_name(table, "Type", obj_type, NULL);
mdb_bind_column_by_name(table, "Flags", obj_flags, NULL);
mdb_rewind_table(table);
while (mdb_fetch_row(table)) {
type = atoi(obj_type);
if (objtype==MDB_ANY || type == objtype) {
entry = (MdbCatalogEntry *) g_malloc0(sizeof(MdbCatalogEntry));
entry->mdb = mdb;
strcpy(entry->object_name, obj_name);
entry->object_type = (type & 0x7F);
entry->table_pg = atol(obj_id) & 0x00FFFFFF;
entry->flags = atol(obj_flags);
mdb->num_catalog++;
g_ptr_array_add(mdb->catalog, entry);
}
}
mdb_free_tabledef(table);
return mdb->catalog;
}
void print_table(MdbTableDef *table)
{
int j;
/* doesn't handle tables > 256 columns. Can that happen? */
char *bound_values[256];
MdbColumn *col;
MdbSarg sarg;
mdb_read_columns(table);
sarg.op = MDB_EQUAL;
// sarg.value.i = 11070;
strcpy(sarg.value.s, "Reggiani Caseifici");
mdb_add_sarg_by_name(table, "ShipName", &sarg);
mdb_rewind_table(table);
for (j=0;j<table->num_cols;j++) {
bound_values[j] = (char *) g_malloc(MDB_BIND_SIZE);
bound_values[j][0] = '\0';
mdb_bind_column(table, j+1, bound_values[j], NULL);
}
/* print header */
col=g_ptr_array_index(table->columns,0);
fprintf(stdout,"%s",col->name);
for (j=1;j<table->num_cols;j++) {
col=g_ptr_array_index(table->columns,j);
fprintf(stdout,"%s%s",DELIMETER,col->name);
}
fprintf(stdout,"\n");
/* print each row */
while(mdb_fetch_row(table)) {
fprintf(stdout,"%s",bound_values[0]);
for (j=1;j<table->num_cols;j++) {
fprintf(stdout,"%s%s",DELIMETER,bound_values[j]);
}
fprintf(stdout,"\n");
}
/* clean up */
for (j=0;j<table->num_cols;j++) {
g_free(bound_values[j]);
}
}
void mdb_data_dump(MdbTableDef *table)
{
unsigned int i;
char *bound_values[MDB_MAX_COLS];
for (i=0;i<table->num_cols;i++) {
bound_values[i] = (char *) g_malloc(256);
mdb_bind_column(table, i+1, bound_values[i], NULL);
}
mdb_rewind_table(table);
while (mdb_fetch_row(table)) {
for (i=0;i<table->num_cols;i++) {
fprintf(stdout, "column %d is %s\n", i+1, bound_values[i]);
}
}
for (i=0;i<table->num_cols;i++) {
g_free(bound_values[i]);
}
}
/**
* mdb_get_relationships
* @mdb: Handle to open MDB database file
* @tablename: Name of the table to process. Process all tables if NULL.
*
* Generates relationships by reading the MSysRelationships table.
* 'szColumn' contains the column name of the child table.
* 'szObject' contains the table name of the child table.
* 'szReferencedColumn' contains the column name of the parent table.
* 'szReferencedObject' contains the table name of the parent table.
* 'grbit' contains integrity constraints.
*
* Returns: a string stating that relationships are not supported for the
* selected backend, or a string containing SQL commands for setting up
* the relationship, tailored for the selected backend.
* Returns NULL on last iteration.
* The caller is responsible for freeing this string.
*/
static char *
mdb_get_relationships(MdbHandle *mdb, const gchar *dbnamespace, const char* tablename)
{
unsigned int i;
gchar *text = NULL; /* String to be returned */
static char *bound[5]; /* Bound values */
static MdbTableDef *table; /* Relationships table */
int backend = 0; /* Backends: 1=oracle, 2=postgres */
char *quoted_table_1, *quoted_column_1,
*quoted_table_2, *quoted_column_2,
*constraint_name, *quoted_constraint_name;
long grbit;
if (!strcmp(mdb->backend_name, "oracle")) {
backend = 1;
} else if (!strcmp(mdb->backend_name, "postgres")) {
backend = 2;
} else {
if (is_init == 0) { /* the first time through */
is_init = 1;
return (char *) g_strconcat(
"-- relationships are not implemented for ",
mdb->backend_name, "\n", NULL);
} else { /* the second time through */
is_init = 0;
return NULL;
}
}
if (is_init == 0) {
table = mdb_read_table_by_name(mdb, "MSysRelationships", MDB_TABLE);
if ((!table) || (table->num_rows == 0)) {
fprintf(stderr, "No MSysRelationships\n");
return NULL;
}
mdb_read_columns(table);
for (i=0;i<5;i++) {
bound[i] = (char *) g_malloc0(MDB_BIND_SIZE);
}
mdb_bind_column_by_name(table, "szColumn", bound[0], NULL);
mdb_bind_column_by_name(table, "szObject", bound[1], NULL);
mdb_bind_column_by_name(table, "szReferencedColumn", bound[2], NULL);
mdb_bind_column_by_name(table, "szReferencedObject", bound[3], NULL);
mdb_bind_column_by_name(table, "grbit", bound[4], NULL);
mdb_rewind_table(table);
is_init = 1;
}
else {
if (!table) {
fprintf(stderr, "table is NULL\n");
}
if (table->cur_row >= table->num_rows) { /* past the last row */
for (i=0;i<5;i++)
g_free(bound[i]);
is_init = 0;
return NULL;
}
}
while (1) {
if (!mdb_fetch_row(table)) {
for (i=0;i<5;i++)
g_free(bound[i]);
is_init = 0;
return NULL;
}
if (!tablename || !strcmp(bound[1], tablename))
break;
}
quoted_table_1 = mdb->default_backend->quote_schema_name(dbnamespace, bound[1]);
quoted_column_1 = mdb->default_backend->quote_schema_name(dbnamespace, bound[0]);
quoted_table_2 = mdb->default_backend->quote_schema_name(dbnamespace, bound[3]);
quoted_column_2 = mdb->default_backend->quote_schema_name(dbnamespace, bound[2]);
grbit = atoi(bound[4]);
constraint_name = g_strconcat(bound[1], "_", bound[0], "_fk", NULL);
quoted_constraint_name = mdb->default_backend->quote_schema_name(dbnamespace, constraint_name);
free(constraint_name);
if (grbit & 0x00000002) {
text = g_strconcat(
"-- Relationship from ", quoted_table_1,
" (", quoted_column_1, ")"
" to ", quoted_table_2, "(", quoted_column_2, ")",
" does not enforce integrity.\n", NULL);
} else {
switch (backend) {
case 1: /* oracle */
case 2: /* postgres */
text = g_strconcat(
"ALTER TABLE ", quoted_table_1,
" ADD CONSTRAINT ", quoted_constraint_name,
" FOREIGN KEY (", quoted_column_1, ")"
" REFERENCES ", quoted_table_2, "(", quoted_column_2, ")",
(grbit & 0x00000100) ? " ON UPDATE CASCADE" : "",
(grbit & 0x00001000) ? " ON DELETE CASCADE" : "",
";\n", NULL);
break;
}
}
free(quoted_table_1);
free(quoted_column_1);
free(quoted_table_2);
free(quoted_column_2);
free(quoted_constraint_name);
return (char *)text;
}
int
main(int argc, char **argv)
{
MdbHandle *mdb;
MdbTableDef *table;
gchar name[256];
gchar *propColName;
void *buf;
int col_num;
int found = 0;
if (argc < 3) {
fprintf(stderr,"Usage: %s <file> <object name> [<prop col>]\n",
argv[0]);
return 1;
}
if (argc < 4)
propColName = "LvProp";
else
propColName = argv[3];
mdb_init();
mdb = mdb_open(argv[1], MDB_NOFLAGS);
if (!mdb) {
mdb_exit();
return 1;
}
table = mdb_read_table_by_name(mdb, "MSysObjects", MDB_ANY);
if (!table) {
mdb_close(mdb);
mdb_exit();
return 1;
}
mdb_read_columns(table);
mdb_rewind_table(table);
mdb_bind_column_by_name(table, "Name", name, NULL);
buf = g_malloc(MDB_BIND_SIZE);
col_num = mdb_bind_column_by_name(table, propColName, buf, NULL);
if (col_num < 1) {
g_free(buf);
mdb_free_tabledef(table);
mdb_close(mdb);
mdb_exit();
printf("Column %s not found in MSysObjects!\n", argv[3]);
return 1;
}
while(mdb_fetch_row(table)) {
if (!strcmp(name, argv[2])) {
found = 1;
break;
}
}
if (found) {
MdbColumn *col = g_ptr_array_index(table->columns, col_num-1);
size_t size;
void *kkd = mdb_ole_read_full(mdb, col, &size);
dump_kkd(mdb, kkd, size);
free(kkd);
}
g_free(buf);
mdb_free_tabledef(table);
mdb_close(mdb);
mdb_exit();
return 0;
}
void
gmdb_table_export_button_cb(GtkWidget *w, gpointer data)
{
gchar *file_path;
FILE *outfile;
gchar *bound_data[256];
MdbTableDef *table;
MdbColumn *col;
int i;
int need_headers = 0;
int need_quote = 0;
gchar delimiter[11];
gchar quotechar;
gchar lineterm[5];
gchar *str;
int rows=0;
GtkWidget *exportwin, *dlg;
gmdb_export_get_delimiter(exportwin_xml, delimiter, 10);
gmdb_export_get_lineterm(exportwin_xml, lineterm, 5);
need_quote = gmdb_export_get_quote(exportwin_xml);
quotechar = gmdb_export_get_quotechar(exportwin_xml);
need_headers = gmdb_export_get_headers(exportwin_xml);
file_path = gmdb_export_get_filepath(exportwin_xml);
// printf("file path %s\n",file_path);
if ((outfile=fopen(file_path, "w"))==NULL) {
GtkWidget* dlg = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (w)),
GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE,
_("Unable to open file."));
gtk_dialog_run (GTK_DIALOG (dlg));
gtk_widget_destroy (dlg);
return;
}
/* read table */
table = mdb_read_table(cat_entry);
mdb_read_columns(table);
mdb_rewind_table(table);
for (i=0;i<table->num_cols;i++) {
/* bind columns */
bound_data[i] = (char *) g_malloc0(MDB_BIND_SIZE);
mdb_bind_column(table, i+1, bound_data[i], NULL);
/* display column titles */
col=g_ptr_array_index(table->columns,i);
if (need_headers) {
if (i>0) fprintf(outfile,delimiter);
gmdb_print_quote(outfile, need_quote, quotechar, delimiter, col->name);
fprintf(outfile,"%s", col->name);
gmdb_print_quote(outfile, need_quote, quotechar, delimiter, col->name);
}
}
if (need_headers) fprintf(outfile,lineterm);
/* fetch those rows! */
while(mdb_fetch_row(table)) {
for (i=0;i<table->num_cols;i++) {
if (i>0) fprintf(outfile,delimiter);
gmdb_print_quote(outfile, need_quote, quotechar, delimiter, bound_data[i]);
fprintf(outfile,"%s", bound_data[i]);
gmdb_print_quote(outfile, need_quote, quotechar, delimiter, bound_data[i]);
}
fprintf(outfile,lineterm);
rows++;
}
/* free the memory used to bind */
for (i=0;i<table->num_cols;i++) {
g_free(bound_data[i]);
}
fclose(outfile);
exportwin = glade_xml_get_widget (exportwin_xml, "export_dialog");
gtk_widget_destroy(exportwin);
dlg = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (w)),
GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE,
_("%d rows successfully exported."), rows);
gtk_dialog_run (GTK_DIALOG (dlg));
gtk_widget_destroy (dlg);
}
int
main (int argc, char **argv)
{
unsigned int j;
MdbHandle *mdb;
MdbTableDef *table;
MdbColumn *col;
/* doesn't handle tables > 256 columns. Can that happen? */
char *bound_values [256];
char delimiter [] = ", ";
char quote_text = 1;
int count = 0;
int started;
if (argc < 3)
{
fprintf (stderr, "Usage: %s <file> <table>\n", argv [0]);
exit (1);
}
mdb_init();
mdb = mdb_open (argv [1], MDB_NOFLAGS);
table = mdb_read_table_by_name (mdb, argv[2], MDB_TABLE);
if (table)
{
mdb_read_columns (table);
mdb_rewind_table (table);
for (j = 0; j < table->num_cols; j++)
{
bound_values [j] = (char *) g_malloc (MDB_BIND_SIZE);
bound_values [j] [0] = '\0';
mdb_bind_column (table, j+1, bound_values[j], NULL);
}
fprintf (stdout, "/******************************************************************/\n");
fprintf (stdout, "/* THIS IS AN AUTOMATICALLY GENERATED FILE. DO NOT EDIT IT!!!!!! */\n");
fprintf (stdout, "/******************************************************************/\n");
fprintf (stdout, "\n");
fprintf (stdout, "#include <stdio.h>\n");
fprintf (stdout, "#include \"types.h\"\n");
fprintf (stdout, "#include \"dump.h\"\n");
fprintf (stdout, "\n");
fprintf (stdout, "const %s %s_array [] = {\n", argv [2], argv [2]);
count = 0;
started = 0;
while (mdb_fetch_row (table))
{
if (started != 0)
{
fprintf (stdout, ",\n");
}
started = 1;
fprintf (stdout, "{\t\t\t\t/* %6d */\n\t", count);
for (j = 0; j < table->num_cols; j++)
{
fprintf (stdout, "\t");
col = g_ptr_array_index (table->columns, j);
if (quote_text &&
(col->col_type == MDB_TEXT ||
col->col_type == MDB_MEMO))
{
fprintf (stdout, "\"%s\"", bound_values [j]);
}
else
{
fprintf (stdout, "%s", bound_values [j]);
}
if (j != table->num_cols - 1)
{
fprintf (stdout, "%s\n", delimiter);
}
else
{
fprintf (stdout, "\n");
}
}
fprintf (stdout, "}");
count++;
}
fprintf (stdout, "\n};\n\n");
for (j = 0; j < table->num_cols; j++)
{
g_free (bound_values [j]);
}
mdb_free_tabledef(table);
}
mdb_close (mdb);
mdb_exit();
fprintf (stdout, "const int %s_array_length = %d;\n",
argv [2],
count);
exit(0);
}
void
gmdb_table_export_button_cb(GtkWidget *w, gpointer data)
{
gchar *file_path;
FILE *outfile;
gchar *bound_data[256];
MdbTableDef *table;
MdbColumn *col;
int i;
int need_headers = 0;
int need_quote = 0;
gchar delimiter[11];
gchar quotechar;
gchar lineterm[5];
gchar *str;
int rows=0;
char msg[100];
GtkWidget *exportwin;
gmdb_export_get_delimiter(exportwin_xml, delimiter, 10);
gmdb_export_get_lineterm(exportwin_xml, lineterm, 5);
need_quote = gmdb_export_get_quote(exportwin_xml);
quotechar = gmdb_export_get_quotechar(exportwin_xml);
need_headers = gmdb_export_get_headers(exportwin_xml);
file_path = gmdb_export_get_filepath(exportwin_xml);
// printf("file path %s\n",file_path);
if ((outfile=fopen(file_path, "w"))==NULL) {
gnome_warning_dialog("Unable to Open File!");
return;
}
/* read table */
table = mdb_read_table(cat_entry);
mdb_read_columns(table);
mdb_rewind_table(table);
for (i=0;i<table->num_cols;i++) {
/* bind columns */
bound_data[i] = (char *) malloc(MDB_BIND_SIZE);
bound_data[i][0] = '\0';
mdb_bind_column(table, i+1, bound_data[i]);
/* display column titles */
col=g_ptr_array_index(table->columns,i);
if (need_headers) {
if (i>0) fprintf(outfile,delimiter);
gmdb_print_quote(outfile, need_quote, quotechar, delimiter, col->name);
fprintf(outfile,"%s", col->name);
gmdb_print_quote(outfile, need_quote, quotechar, delimiter, col->name);
}
}
if (need_headers) fprintf(outfile,lineterm);
/* fetch those rows! */
while(mdb_fetch_row(table)) {
for (i=0;i<table->num_cols;i++) {
if (i>0) fprintf(outfile,delimiter);
gmdb_print_quote(outfile, need_quote, quotechar, delimiter, bound_data[i]);
fprintf(outfile,"%s", bound_data[i]);
gmdb_print_quote(outfile, need_quote, quotechar, delimiter, bound_data[i]);
}
fprintf(outfile,lineterm);
rows++;
}
/* free the memory used to bind */
for (i=0;i<table->num_cols;i++) {
free(bound_data[i]);
}
fclose(outfile);
exportwin = glade_xml_get_widget (exportwin_xml, "export_dialog");
gtk_widget_destroy(exportwin);
sprintf(msg,"%d Rows exported successfully.\n", rows);
gnome_ok_dialog(msg);
}
int
main(int argc, char **argv)
{
int i, row;
MdbHandle *mdb;
MdbTableDef *table;
MdbField fields[256];
char line[MAX_ROW_SIZE];
int num_fields;
/* doesn't handle tables > 256 columns. Can that happen? */
int opt;
FILE *in;
char delimiter[2] = ",";
char header_rows = 0;
while ((opt=getopt(argc, argv, "H:d:"))!=-1) {
switch (opt) {
case 'H':
header_rows = atol(optarg);
break;
case 'd':
delimiter[0] = optarg[0];
break;
default:
break;
}
}
/*
** optind is now the position of the first non-option arg,
** see getopt(3)
*/
if (argc-optind < 3) {
fprintf(stderr,"Usage: %s [options] <database> <table> <csv file>\n",argv[0]);
fprintf(stderr,"where options are:\n");
fprintf(stderr," -H <rows> skip <rows> header rows\n");
fprintf(stderr," -d <delimiter> specify a column delimiter\n");
exit(1);
}
if (!(mdb = mdb_open(argv[optind], MDB_WRITABLE))) {
exit(1);
}
table = mdb_read_table_by_name(mdb, argv[argc-2], MDB_TABLE);
if (!table) {
fprintf(stderr,"Table %s not found in database\n", argv[argc-2]);
exit(1);
}
mdb_read_columns(table);
mdb_read_indices(table);
mdb_rewind_table(table);
/*
* open the CSV file and read any header rows
*/
in = fopen(argv[argc-1], "r");
if (!in) {
fprintf(stderr, "Can not open file %s\n", argv[argc-1]);
exit(1);
}
for (i=0;i<header_rows;i++)
if (!fgets(line, MAX_ROW_SIZE, in)) {
fprintf(stderr, "Error while reading header column #%d. Check -H parameter.\n", i);
exit(1);
}
row = 1;
while (fgets(line, MAX_ROW_SIZE, in)) {
num_fields = prep_row(table, line, fields, delimiter);
if (!num_fields) {
fprintf(stderr, "Aborting import at row %d\n", row);
exit(1);
}
/*
* all the prep work is done, let's add the row
*/
mdb_insert_row(table, num_fields, fields);
}
mdb_free_tabledef(table);
fclose(in);
mdb_close(mdb);
return 0;
}
/* functions */
GtkWidget *
gmdb_table_data_new(MdbCatalogEntry *entry)
{
MdbTableDef *table;
MdbColumn *col;
GtkWidget *clist;
GtkWidget *scroll;
int i, rownum;
long row, maxrow;
gchar *bound_data[256];
GMdbDataWindow *dataw = NULL;
/* do we have an active window for this object? if so raise it */
for (i=0;i<g_list_length(window_list);i++) {
dataw = g_list_nth_data(window_list, i);
if (!strcmp(dataw->table_name, entry->object_name)) {
gdk_window_raise (dataw->window->window);
return dataw->window;
}
}
dataw = g_malloc(sizeof(GMdbDataWindow));
strcpy(dataw->table_name, entry->object_name);
dataw->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(dataw->window), entry->object_name);
gtk_widget_set_usize(dataw->window, 300,200);
gtk_widget_set_uposition(dataw->window, 50,50);
gtk_widget_show(dataw->window);
gtk_signal_connect (GTK_OBJECT (dataw->window), "delete_event",
GTK_SIGNAL_FUNC (gmdb_table_data_close), dataw);
scroll = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_show (scroll);
gtk_container_add(GTK_CONTAINER(dataw->window), scroll);
/* read table */
table = mdb_read_table(entry);
mdb_read_columns(table);
mdb_rewind_table(table);
clist = gtk_clist_new(table->num_cols);
gtk_widget_show(clist);
gtk_container_add(GTK_CONTAINER(scroll),clist);
for (i=0;i<table->num_cols;i++) {
/* bind columns */
bound_data[i] = (char *) g_malloc0(MDB_BIND_SIZE);
mdb_bind_column(table, i+1, bound_data[i], NULL);
/* display column titles */
col=g_ptr_array_index(table->columns,i);
gtk_clist_set_column_title(GTK_CLIST(clist), i, col->name);
}
gtk_clist_column_titles_show(GTK_CLIST(clist));
maxrow = gmdb_prefs_get_maxrows();
/* fetch those rows! */
row = 0;
while(mdb_fetch_row(table) &&
(!maxrow || (row < maxrow))) {
row++;
rownum = gtk_clist_append(GTK_CLIST(clist), bound_data);
}
/* free the memory used to bind */
for (i=0;i<table->num_cols;i++) {
g_free(bound_data[i]);
}
/* add this one to the window list */
window_list = g_list_append(window_list, dataw);
return dataw->window;
}
