---

export.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 <string.h>
#include "buf.h"
#include "dialogs.h"
#include "exporthtml.h"
#include "exporttext.h"
#include "gui_common.h"
#include "queries.h"

#define TYPE_KEY "Type key"

typedef struct _export_data {
    GtkWidget *type_menu;   
    GtkWidget *query;       
    char *query_name;       
} ExportData;

static char *types[] = {
    "Choose from extension",
    "",
    "Html",
    "Text",
    NULL
};

static char *noExtensions[] = { NULL }; 
static char *htmlExtensions[] = { "html", "htm", NULL };    
static char *textExtensions[] = { "txt", "", NULL };        
static char **typesExtensions[] = {
    noExtensions, noExtensions,
    htmlExtensions, textExtensions,
    NULL
};

void export_dialog_hide();

void export_dialog_show(char *title);

void export_dialog_create();

static void (*exportFunctions[]) () = {
    NULL,
    NULL,
    export_as_html,
    export_as_text,
    NULL
};

static GtkWidget *exportDialog = NULL;

static int exportDialogDisplayed = 0;

ExportData exportData = {
    NULL,                              /* GtkWidget *type_menu; */
    NULL,                              /* GtkWidget *query; */
    NULL                               /* char *query_name; */
};

void add_entry_line(char *labeltext, GtkWidget * widget,
                           GtkWidget * table, int height)
{
    GtkWidget *label;

    label = gtk_label_new(labeltext);
    gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1,
                              height, height + 1);
    gtk_widget_show(label);

    gtk_table_attach_defaults(GTK_TABLE(table), widget, 1, 2,
                              height, height + 1);
}

//static void common_cancel_callback(GtkWidget * widget, gpointer data)
//{
//  CommonExportData *cd = (CommonExportData *) data;
//
//  gtk_widget_hide(GTK_WIDGET(cd->dialog));
//}

int export_in_progress()
{
    return exportDialogDisplayed;
}

static GtkWidget *create_type_menu()
{
    GtkWidget *optionmenu, *menu;
    int i;

    optionmenu = gtk_option_menu_new();
    menu = gtk_menu_new();

    i = 0;
    while (types[i] != NULL) {
        GtkWidget *menuitem;

        if (strlen(types[i]) == 0)
            menuitem = gtk_menu_item_new();
        else
            menuitem = gtk_menu_item_new_with_label(types[i]);

        gtk_object_set_data(GTK_OBJECT(menuitem), TYPE_KEY, (gpointer) i);

        gtk_menu_append(GTK_MENU(menu), menuitem);
        gtk_widget_show(menuitem);

        i++;
    }

    gtk_option_menu_set_menu(GTK_OPTION_MENU(optionmenu), menu);

    return optionmenu;
}

void export_cancel_callback(GtkWidget * widget, gpointer data)
{
    gtk_widget_hide(GTK_WIDGET(exportDialog));
    exportDialogDisplayed = 0;
    update_button_sensitivity();
}

void export_ok_callback(GtkWidget * widget, gpointer data)
{
    GtkFileSelection *fs = GTK_FILE_SELECTION(exportDialog);
    GtkWidget *type_w;
    char *filename, *raw_filename;
    int type;

    /* We get the file name */
    filename = gtk_file_selection_get_filename(fs);
    raw_filename = gtk_entry_get_text(GTK_ENTRY(fs->selection_entry));

    if (((filename == NULL) || (strlen(filename) == 0)) ||
        ((raw_filename == NULL) || (strlen(raw_filename) == 0))) {
        display_error("Export Error", "No filename specified.");
        export_cancel_callback(widget, data);
        return;
    }

    /* Makes a copy of the resources. Make sure these are freed later. */
    filename = g_strdup(filename);
    raw_filename = g_strdup(raw_filename);

    /* First, we need to find what is in the menu */
    type_w = gtk_menu_get_active(GTK_MENU(exportData.type_menu));
    type = (int) gtk_object_get_data(GTK_OBJECT(type_w), TYPE_KEY);
    if (type == 0) {
        /* Need to find extension */
        int l = strlen(raw_filename), j;
        char *ext;

        while ((l >= 0) && (raw_filename[l] != '.'))
            l--;

        if (l < 0)
            ext = raw_filename + strlen(raw_filename);
        else
            ext = raw_filename + l + 1;

        /* Need to find corresponding code */
        type = 0;
        while (typesExtensions[type] != NULL) {
            j = 0;
            while (typesExtensions[type][j] != NULL) {
                if (!strcasecmp(typesExtensions[type][j], ext))
                    goto end;
                j++;
            }
            type++;
        }

      end:
        if (typesExtensions[type] == NULL) {
            g_free(filename);
            g_free(raw_filename);
            return;
        }
    }

    /* We call the corresponding dialog */
    if (exportFunctions[type] == NULL) {
        g_warning("Internal error. Export function not specified.\n");
        return;
    }
    (exportFunctions[type]) (filename, raw_filename,
                             GTK_TEXT(exportData.query),
                             exportData.query_name);

    /* Now, we can hide the dialog */
    export_dialog_hide();
    update_button_sensitivity();
    if (filename)
        g_free(filename);

    if (raw_filename)
        g_free(raw_filename);
}

gint delete_event(GtkWidget * widget, GdkEvent * event, gpointer data)
{
    /* We call the cancel callback to hide the dialog.  */
    export_cancel_callback(widget, data);

    /* Don't delete it. It will be re-used. */
    return (TRUE);
}

void result_export()
{
#define EXPORTINGQUERY_S    "Exporting query '%s'"
    ABuf *buf = NULL;
    char *qname;

    if (exportDialogDisplayed)
        /* Should never happen */
        return;

    qname = query_get_current_name();
    buf = buf_new(strlen(EXPORTINGQUERY_S) + strlen(qname));
    if (!buf) {
        g_warning("ExportQueryDialog() could not allocate a buffer\n");
        return;
    }

    snprintf(buf->b_dat, buf->b_len, EXPORTINGQUERY_S, qname);
    export_dialog_show(buf->b_dat);
    buf_free(buf);
}

void export_dialog_hide()
{
    if (exportDialog == NULL)
        return;

    exportDialogDisplayed = 0;
    gtk_widget_hide(exportDialog);
}

void export_dialog_show(char *title)
{
    if (exportDialog == NULL) {
        export_dialog_create();
        if (exportDialog == NULL)
            return;
    }

    gtk_window_set_title(GTK_WINDOW(exportDialog), title);

    /* Setup the dialog data. */
    exportData.query = query_get_current();
    exportData.query_name = query_get_current_name();
    exportDialogDisplayed = 1;
    gtk_widget_show(exportDialog);
}

void export_dialog_create()
{
    GtkWidget *frame, *menu;
    if (exportDialog != NULL)
        return;

    exportDialog = gtk_file_selection_new("Export...");
    gtk_file_selection_show_fileop_buttons(GTK_FILE_SELECTION(exportDialog));
    gtk_file_selection_set_filename(GTK_FILE_SELECTION(exportDialog), getenv("HOME"));
    exportDialogDisplayed = 0;

    /* Now, we create the save options */
    frame = gtk_frame_new("Export Type");
    gtk_container_border_width(GTK_CONTAINER(frame), 5);

    menu = create_type_menu();
    gtk_widget_show(menu);
    gtk_container_add(GTK_CONTAINER(frame), menu);

    gtk_widget_show(frame);
    gtk_box_pack_end(GTK_BOX(GTK_FILE_SELECTION(exportDialog)->main_vbox),
                     frame, FALSE, FALSE, 5);

    /* Setup the dialog data. */
    exportData.type_menu = gtk_option_menu_get_menu(GTK_OPTION_MENU(menu));
    exportData.query = query_get_current();
    exportData.query_name = query_get_current_name();
    exportData.type_menu = gtk_option_menu_get_menu(GTK_OPTION_MENU(menu));

    /* Now, we connect the signals */
    gtk_signal_connect(GTK_OBJECT(exportDialog), "delete_event",
                       GTK_SIGNAL_FUNC(delete_event), NULL);
    gtk_signal_connect(GTK_OBJECT
                       (GTK_FILE_SELECTION(exportDialog)->cancel_button),
                       "clicked", GTK_SIGNAL_FUNC(export_cancel_callback),
                       NULL);
    gtk_signal_connect(GTK_OBJECT
                       (GTK_FILE_SELECTION(exportDialog)->ok_button),
                       "clicked", GTK_SIGNAL_FUNC(export_ok_callback), NULL);
}

---