---

exporttext.c

Go to the documentation of this file.

/* GtkSQL -- an interactive graphical query tool for PostgreSQL
 * Copyright (C) 1998-2003  Lionel ULMER, Darryl Luff.
 *
 * This program is free software; you can redistribute it andraw/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#include <gtk/gtk.h>
#include <string.h>
#include "buf.h"
#include "export.h"
#include "guiapi.h"
#include "queries.h"
#include "status.h"
#include "utils.h"

typedef struct _text_export_data {
    GtkWidget *dialog;      
    char *filename;         
    char *raw_filename;     
    GtkWidget *query;       
    GtkWidget *separator;   
    GtkWidget *pprint;      
} TextExportData;


void export_text_dialog_hide();

void export_text_dialog_show(char *title, char *filename, char *name,
                             GtkWidget * query);

void export_text_dialog_create();

static GtkWidget *exportTextDialog = NULL;

static int exportTextDialogDisplayed = 0;

TextExportData exportTextData = {
    NULL,                              /* GtkWidget *dialog; */
    NULL,                              /* char *filename; */
    NULL,                              /* char *raw_filename; */
    NULL,                              /* GtkWidget *query; */
    NULL,                              /* GtkWidget *separator; */
    NULL                               /* GtkWidget *pprint; */
};

static void text_export_ok_callback(GtkWidget * widget, gpointer data)
{
    TextExportData *cd = (TextExportData *) data;
    int pprint;
    char *sep;
    char *tab = "\t", *space = " ";
    FILE *f;
    void *result;
    char *field;
    DBConnection *conn;

    /* Get the parameters */
    pprint = GTK_TOGGLE_BUTTON(cd->pprint)->active;
    sep = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(cd->separator)->entry));
    if (!strcmp(sep, "TAB"))
        sep = tab;
    else if (!strcmp(sep, "SPACE"))
        sep = space;

    /* Opens the file */
    if ((cd == NULL) || (cd->filename == NULL)) {
        g_warning("Null filename entered\n");
        return;
    }

    f = fopen(cd->filename, "wb");
    if (f == NULL) {
        perror("opening export file");
        return;
    }

    /* Start exporting ... */
    result = query_get_result(cd->query);

    conn = gui_get_connection();
    if ((result)
        && (conn->DBget_query_status(conn, result) == DB_QUERY_RECORDS_OK)) {
        int nb_tuples = conn->DBget_record_number(conn, result);
        int nb_cols = conn->DBget_field_number(conn, result);
        int *col_length = (int *) g_malloc(sizeof(int) * nb_cols);
        int i, j;

        if (nb_tuples > 0) {
            /* Pretty Printing */
            if (pprint) {
                for (j = 0; j < nb_cols; j++)
                    col_length[j] = 0;

                for (i = 0; i < nb_tuples; i++)
                    for (j = 0; j < nb_cols; j++) {
                        field = conn->DBget_field_value(conn, result, i, j);
                        if (field != NULL)
                            if (strlen(field) > col_length[j])
                                col_length[j] = strlen(field);
                    }
            }

            status_push("Exporting Text...");
            progress_reset();

            /* Print the data */
            for (i = 0; i < nb_tuples; i++) {
                for (j = 0; j < nb_cols; j++) {
                    if (j > 0)
                        fprintf(f, "%s", sep);

                    field = conn->DBget_field_value(conn, result, i, j);
                    if (!field)
                        field = "";

                    fprintf(f, "%s", field);

                    if (pprint)
                        add_space(f, strlen(field), col_length[j]);
                }
                progress_update(i / (float) nb_tuples);
                fprintf(f, "\n");
            }
            g_free(col_length);
        }
    }

    /* Closes the file */
    fclose(f);

    /* Close the dialog */
    progress_reset();
    status_pop();

    export_text_dialog_hide();
}

static void export_text_cancel_callback(GtkWidget * widget, gpointer data)
{
    CommonExportData *cd = (CommonExportData *) data;

    gtk_widget_hide(GTK_WIDGET(cd->dialog));
}

void export_text_dialog_create()
{
#define EXPORT_S "Export '%s' as text"
    GtkWidget *sep_combo;
    GtkWidget *table, *vbox;
    GtkWidget *pp_button;
    GtkWidget *ok_button, *cancel_button;
    ABuf *buf = NULL;
    char *sep[] = { ",", ";", "TAB", "SPACE", "-", "|", NULL };
    int i;
    GList *cbitems = NULL;

    if (exportTextDialog != NULL)
        return;

    /* The dialog */
    exportTextDialog = gtk_dialog_new();
    gtk_window_set_title(GTK_WINDOW(exportTextDialog), "Export Text...");
    gtk_window_position(GTK_WINDOW(exportTextDialog), GTK_WIN_POS_MOUSE);
    gtk_window_set_policy(GTK_WINDOW(exportTextDialog), FALSE, FALSE, FALSE);

    /* The vbox */
    vbox = gtk_vbox_new(FALSE, 5);
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(exportTextDialog)->vbox), vbox,
                       FALSE, FALSE, 0);
    gtk_widget_show(vbox);

    /* The table to have a nice layout :-) */
    table = gtk_table_new(3, 2, FALSE);
    gtk_container_border_width(GTK_CONTAINER(table), 6);

    /* The combo box for the separator */
    for (i = 0; sep[i] != NULL; i++)
        cbitems = g_list_append(cbitems, sep[i]);
    sep_combo = gtk_combo_new();
    gtk_combo_set_popdown_strings(GTK_COMBO(sep_combo), cbitems);
    gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(sep_combo)->entry), sep[0]);
    gtk_widget_show(sep_combo);
    add_entry_line("Separator : ", sep_combo, table, 0);

    /* End of table "layout" */
    gtk_widget_show(table);
    gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);

    /* The pretty print button */
    pp_button = gtk_check_button_new_with_label("Pretty print");
    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(pp_button), FALSE);
    gtk_widget_show(pp_button);
    gtk_box_pack_start(GTK_BOX(vbox), pp_button, FALSE, FALSE, 0);

    ok_button = gtk_button_new_with_label("Ok");
    gtk_signal_connect(GTK_OBJECT(ok_button), "clicked",
                       GTK_SIGNAL_FUNC(text_export_ok_callback),
                       &exportTextData);
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(exportTextDialog)->action_area),
                       ok_button, FALSE, FALSE, 0);
    GTK_WIDGET_SET_FLAGS(ok_button, GTK_CAN_DEFAULT);
    gtk_widget_grab_default(ok_button);
    gtk_widget_show(ok_button);
    cancel_button = gtk_button_new_with_label("Cancel");
    gtk_signal_connect(GTK_OBJECT(cancel_button), "clicked",
                       GTK_SIGNAL_FUNC(export_text_cancel_callback),
                       exportTextDialog);
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(exportTextDialog)->action_area),
                       cancel_button, FALSE, FALSE, 0);
    gtk_widget_show(cancel_button);

    /* Now, the dialog data. */
    exportTextData.dialog = exportTextDialog;
    exportTextData.separator = sep_combo;
    exportTextData.pprint = pp_button;

    buf_free(buf);
}

void export_text_dialog_hide()
{
    exportTextDialogDisplayed = 0;
    gtk_widget_hide(GTK_WIDGET(exportTextDialog));
}

void export_text_dialog_show(char *title, char *filename, char *rawfilename,
                             GtkWidget * query)
{
    if (exportTextDialogDisplayed)
        return;

    if (exportTextDialog == NULL) {
        export_text_dialog_create();
        if (exportTextDialog == NULL)
            return;
    }

    if (exportTextData.filename)
        g_free(exportTextData.filename);
    exportTextData.filename = g_strdup(filename);
    
    if (exportTextData.raw_filename)
        g_free(exportTextData.raw_filename);
    exportTextData.raw_filename = g_strdup(rawfilename);

    exportTextData.query = query;

    gtk_window_set_title(GTK_WINDOW(exportTextDialog), title);
    exportTextDialogDisplayed = 1;
    gtk_widget_show(GTK_WIDGET(exportTextDialog));
}

void export_as_text(char *filename, char *rawfilename,
                           GtkWidget * query, char *query_name)
{
    ABuf *buf = NULL;

    export_text_dialog_create();
    buf = buf_new(strlen(EXPORT_S) + strlen(query_name));
    snprintf(buf->b_dat, buf->b_len, "Export '%s' as text", query_name);
    export_text_dialog_show(buf->b_dat, filename, rawfilename, query);

    buf_free(buf);
}

---