png_im_export.C

Go to the documentation of this file.

/* Gnome gxsm - Gnome X Scanning Microscopy
 * universal STM/AFM/SARLS/SPALEED/... controlling and
 * data analysis software
 *
 * Gxsm Plugin Name: png_im_export.C
 * ========================================
 * 
 * Copyright (C) 1999 The Free Software Foundation
 *
 * Authors: Percy Zahl <zahl@fkp.uni-hannover.de>
 * additional features: Andreas Klust <klust@fkp.uni-hannover.de>
 *
 * This program is free software; you can redistribute it and/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.
 */

/* Please do not change the Begin/End lines of this comment section!
 * this is a LaTeX style section used for auto generation of the PlugIn Manual 
 * Chapter. Add a complete PlugIn documentation inbetween the Begin/End marks!
 * --------------------------------------------------------------------------------
% BeginPlugInDocuSection
% PlugInDocuCaption: PNG image Import/Export
% PlugInName: png_Im_Export
% PlugInAuthor: Percy Zahl
% PlugInAuthorEmail: zahl@users.sf.net
% PlugInMenuPath: File/Import/PNG

% PlugInDescription
The \GxsmEmph{png\_im\_export} plug-in allows reading and writing of images using the
Portabe Network Graphics (PNG) image format. 

The currently set palette is used if non is used or available a grey
scale image is generated. The currect set view mode
(Direct/Quick/...) is used for automatic data transformation. The resulting image will
appear like the active view but it has the size of the original scan (no zoom/quench applies).

A special feature: If the scan has type "RGBA" (4 layers) the raw data of the channels is written
without any transfornation or scaling to the PNG file in RGB mode.

% PlugInUsage
The plug-in is called by \GxsmMenu{File/Import/PNG} and \GxsmMenu{File/Export/PNG}.

%% OptPlugInKnownBugs

% OptPlugInRefs
pnglib documentation: \GxsmWebLink{www.libpng.org/pub/png/libpng-manual.html}


% EndPlugInDocuSection
 * -------------------------------------------------------------------------------- 
 */

#include <gtk/gtk.h>
#include "config.h"
#include "gxsm/plugin.h"
#include "gxsm/dataio.h"
#include "gxsm/action_id.h"
#include "gxsm/util.h"
#include "gxsm/xsmtypes.h"
#include "gxsm/glbvars.h"

// custom includes go here
// -- START EDIT --
#include "png.h"        /* libpng header; includes zlib.h */
#include "readpng.h"    /* typedefs, common macros, public prototypes */
#include "writepng.h"    /* typedefs, common macros, public prototypes */
// -- END EDIT --

// enable std namespace
using namespace std;

// Plugin Prototypes
static void png_im_export_init (void);
static void png_im_export_query (void);
static void png_im_export_about (void);
static void png_im_export_configure (void);
static void png_im_export_cleanup (void);

static void png_im_export_filecheck_load_callback (gpointer data );
static void png_im_export_filecheck_save_callback (gpointer data );

static void png_im_export_import_callback (GtkWidget *w, void *data);
static void png_im_export_export_callback (GtkWidget *w, void *data);

// Fill in the GxsmPlugin Description here
GxsmPlugin png_im_export_pi = {
  NULL,                   // filled in and used by Gxsm, don't touch !
  NULL,                   // filled in and used by Gxsm, don't touch !
  0,                      // filled in and used by Gxsm, don't touch !
  NULL,                   // The Gxsm-App Class Ref.pointer (called "gapp" in Gxsm) is 
                          // filled in here by Gxsm on Plugin load, 
                          // just after init() is called !!!
// -- START EDIT --
  "PNG-ImExport",            // PlugIn name
  NULL,                   // PlugIn's Categorie, set to NULL for all, I just don't want this always to be loaded!
  // Description, is shown by PluginViewer (Plugin: listplugin, Tools->Plugin Details)
  "Im/Export PNG images.",
  "Percy Zahl",
  N_("_File/_Import/,_File/_Export/"), // sep. im/export menuentry path by comma!
  N_("PNG,PNG"), // menu entry (same for both)
  N_("PNG import,PNG export"), // short help for menu entry
  N_("PNG import and export filter."), // info
// -- END EDIT --
  NULL,          // error msg, plugin may put error status msg here later
  NULL,          // Plugin Status, managed by Gxsm, plugin may manipulate it too
  png_im_export_init,
  png_im_export_query,
  // about-function, can be "NULL"
  // can be called by "Plugin Details"
  png_im_export_about,
  // configure-function, can be "NULL"
  // can be called by "Plugin Details"
  png_im_export_configure,
  // run-function, can be "NULL", if non-Zero and no query defined, 
  // it is called on menupath->"plugin"
  NULL,
  // cleanup-function, can be "NULL"
  // called if present at plugin removeal
  png_im_export_cleanup
};

// Text used in Aboutbox, please update!!
static const char *about_text = N_("This GXSM plugin allows im- and export of PNG image data files");

static const char *file_mask = "*.png";

// Symbol "get_gxsm_plugin_info" is resolved by dlsym from Gxsm, used to get Plugin's info!! 
// Essential Plugin Function!!
GxsmPlugin *get_gxsm_plugin_info ( void ){ 
  png_im_export_pi.description = g_strdup_printf(N_("Gxsm im_export plugin %s"), VERSION);
  return &png_im_export_pi; 
}

// Query Function, installs Plugin's in File/Import and Export Menupaths!
// ----------------------------------------------------------------------
// Import Menupath is "File/Import/PNG"
// Export Menupath is "File/Export/PNGt"
// ----------------------------------------------------------------------

static void png_im_export_query(void)
{
        gchar **path  = g_strsplit (png_im_export_pi.menupath, ",", 2);
        gchar **entry = g_strsplit (png_im_export_pi.menuentry, ",", 2);
        gchar **help  = g_strsplit (png_im_export_pi.help, ",", 2);

        static GnomeUIInfo menuinfo_i[] = { 
                { GNOME_APP_UI_ITEM, NULL, NULL,
                  NULL, NULL,
                  NULL, GNOME_APP_PIXMAP_STOCK, GNOME_STOCK_MENU_OPEN,
                  0, GDK_CONTROL_MASK, NULL },
                GNOMEUIINFO_END
        };
        menuinfo_i[0].label  = entry[0];
        menuinfo_i[0].hint   = help[0];
        menuinfo_i[0].moreinfo  = (gpointer) png_im_export_import_callback; 
        menuinfo_i[0].user_data = png_im_export_pi.name;

        gnome_app_insert_menus (
                GNOME_APP(png_im_export_pi.app->getApp()), 
                path[0], 
                menuinfo_i
                );
        

        static GnomeUIInfo menuinfo_e[] = { 
                { GNOME_APP_UI_ITEM, NULL, NULL,
                  NULL, NULL,
                  NULL, GNOME_APP_PIXMAP_STOCK, GNOME_STOCK_MENU_SAVE,
                  0, GDK_CONTROL_MASK, NULL },
                GNOMEUIINFO_END
        };
        menuinfo_e[0].label  = entry[1];
        menuinfo_e[0].hint   = help[1];
        menuinfo_e[0].moreinfo  = (gpointer) png_im_export_export_callback; 
        menuinfo_e[0].user_data = png_im_export_pi.name;

        gnome_app_insert_menus (
                GNOME_APP(png_im_export_pi.app->getApp()), 
                path[1],
                menuinfo_e
                );

        if(png_im_export_pi.status) g_free(png_im_export_pi.status); 
        png_im_export_pi.status = g_strconcat (
                N_("Plugin query has attached "),
                png_im_export_pi.name, 
                N_(": File IO Filters are ready to use."),
                NULL);
        
        // clean up
        g_strfreev (path);
        g_strfreev (entry);
        g_strfreev (help);

        // register this plugins filecheck functions with Gxsm now!
        // This allows Gxsm to check files from DnD, open, 
        // and cmdline sources against all known formats automatically - no explicit im/export is necessary.
        png_im_export_pi.app->ConnectPluginToLoadFileEvent (png_im_export_filecheck_load_callback);
        png_im_export_pi.app->ConnectPluginToSaveFileEvent (png_im_export_filecheck_save_callback);
}


// 5.) Start here with the plugins code, vars def., etc.... here.
// ----------------------------------------------------------------------
//


// init-Function
static void png_im_export_init(void)
{
        PI_DEBUG (DBG_L2, png_im_export_pi.name << " Plugin Init");
}

// about-Function
static void png_im_export_about(void)
{
        const gchar *authors[] = { png_im_export_pi.authors, NULL};
        gtk_widget_show(gnome_about_new ( png_im_export_pi.name,
                                          VERSION,
                                          N_("(C) 2001 the Free Software Foundation"),
                                          about_text,
                                          authors,
                                          NULL, NULL, NULL
                                          ));
}

// configure-Function
static void png_im_export_configure(void)
{
        if(png_im_export_pi.app)
                png_im_export_pi.app->message("PNG im_export Plugin Configuration");
}

// cleanup-Function, remove all "custom" menu entrys here!
static void png_im_export_cleanup(void)
{
        gchar **path  = g_strsplit (png_im_export_pi.menupath, ",", 2);
        gchar **entry = g_strsplit (png_im_export_pi.menuentry, ",", 2);

        gchar *tmp = g_strconcat (path[0], entry[0], NULL);
        gnome_app_remove_menus (GNOME_APP (png_im_export_pi.app->getApp()), tmp, 1);
        g_free (tmp);

        tmp = g_strconcat (path[1], entry[1], NULL);
        gnome_app_remove_menus (GNOME_APP (png_im_export_pi.app->getApp()), tmp, 1);
        g_free (tmp);

        g_strfreev (path);
        g_strfreev (entry);

        PI_DEBUG (DBG_L2, "Plugin Cleanup done.");
}


// make a new derivate of the base class "Dataio"
class PNG_ImExportFile : public Dataio{
public:
        PNG_ImExportFile(Scan *s, const char *n) : Dataio(s,n){; };
        virtual FIO_STATUS Read();
        virtual FIO_STATUS Write();
private:
        FIO_STATUS import_data(const char *fname); 
};

FIO_STATUS PNG_ImExportFile::Read(){
        FIO_STATUS ret;
        gchar *fname=NULL;

        PI_DEBUG (DBG_L2, "reading");

        fname = (gchar*)name;

        // name should have at least 4 chars: ".ext"
        if (fname == NULL || strlen(fname) < 4)
                return status=FIO_NOT_RESPONSIBLE_FOR_THAT_FILE;

        if (strncasecmp(fname+strlen(fname)-4,".png",4)){
                return status=FIO_NOT_RESPONSIBLE_FOR_THAT_FILE;
        }
 
        // check for file exists and is OK !
        // else open File Dlg
        ifstream f;
        f.open(fname, ios::in);
        if(!f.good()){
                PI_DEBUG (DBG_L2, "Error at file open. File not good/readable.");
                return status=FIO_OPEN_ERR;
        }
        f.close();

        // Check all known File Types:
        if ((ret=import_data (fname)) !=  FIO_NOT_RESPONSIBLE_FOR_THAT_FILE)
                return ret;

        return  status=FIO_NOT_RESPONSIBLE_FOR_THAT_FILE;
}

FIO_STATUS PNG_ImExportFile::import_data(const char *fname){
        FILE *infile;
        double display_exponent;
        ulg image_width, image_height, image_rowbytes;
        int image_channels;
        int rc;
        
        gboolean byteswap = FALSE;

        // Checking resposibility for this file as good as possible, use
        // extension(s) (most simple), magic numbers, etc.
        ifstream f;
        GString *FileList=NULL;

        cout << "PNG::: importing from >" << fname << "<" << endl;
        PI_DEBUG (DBG_L2, "importing from >" << fname << "<");

        if (!(infile = fopen(fname, "rb")))
                return status=FIO_OPEN_ERR;

        cout << "PNG::: reset to defaults" << endl;

        // reset old scan fully to defaults
        SCAN_DATA scan_template;
//      scan->data.CpUnits (scan_template);
        scan->data.GetScan_Param (scan_template);
//      scan->data.GetLayer_Param (scan_template);
        scan->data.GetUser_Info (scan_template);
//      scan->data.GetDSP_Param (scan_template);
        scan->data.GetDisplay_Param (scan_template);

        cout << "PNG::: readpng" << endl;
        // now start importing -----------------------------------------
        if ((rc = readpng_init(infile, &image_width, &image_height)) != 0) {
                gchar *error_msg = NULL;
                switch (rc) {
                case 1:
                        PI_DEBUG (DBG_L2, "[" << fname << "] is not a PNG file: incorrect signature");
                        error_msg = g_strdup_printf (N_("[%s] is not a PNG file: incorrect signature"),
                                                     fname);
                        break;
                case 2:
                        PI_DEBUG (DBG_L2, "[" << fname << "] has bad IHDR (libpng longjmp)");
                        error_msg = g_strdup_printf (N_("[%s] has bad IHDR (libpng longjmp)"),
                                                     fname);
                        break;
                case 4:
                        PI_DEBUG (DBG_L2, "insufficient memory");
                        error_msg = g_strdup_printf (N_("insufficient memory"));
                        break;
                default:
                        PI_DEBUG (DBG_L2, "unknown readpng_init() error");
                        error_msg = g_strdup_printf (N_("unknown readpng_init() error"));
                        break;
                }
   
                cout << error_msg << endl;
        
                if (error_msg && (rc > 1 || strstr (fname, ".png"))){
                        GtkWidget *dialog = gtk_message_dialog_new (NULL,
                                                                    GTK_DIALOG_DESTROY_WITH_PARENT,
                                                                    GTK_MESSAGE_INFO,
                                                                    GTK_BUTTONS_OK,
                                                                    error_msg);
                        gtk_dialog_run (GTK_DIALOG (dialog));
                        g_signal_connect_swapped (GTK_OBJECT (dialog), "response",
                                                  G_CALLBACK (gtk_widget_destroy),
                                                  GTK_OBJECT (dialog));
                }
                g_free (error_msg);
                fclose (infile);
                return FIO_NOT_RESPONSIBLE_FOR_THAT_FILE;
        }

        // update as much as we get...
        time_t t; // Scan - Startzeit eintragen 
        time(&t);
        gchar *tmp = g_strconcat ((ctime(&t)), " (Imported)", NULL); scan->data.ui.SetDateOfScan (tmp); g_free (tmp);
        scan->data.ui.SetName (name);
        scan->data.ui.SetOriginalName (name);
        scan->data.ui.SetType ("PNG color image");
        scan->data.ui.SetUser ("nobody");

        FileList = g_string_new ("Imported by GXSM from PNG.\n");
        g_string_sprintfa (FileList, "Original Filename: %s\n", name);
        g_string_append (FileList, "blaaa:\n");
        scan->data.ui.SetComment (FileList->str);
        g_string_free(FileList, TRUE); 
        FileList=NULL;


        XsmRescourceManager xrm("PNG_IM_EXPORT");
        xrm.Get ("AngPerPixelX", &scan->data.s.dx, "1.0"),
        xrm.Get ("AngPerPixelY", &scan->data.s.dy, "1.0"),

        scan->data.s.ntimes = 1;
        scan->data.s.nvalues = 4;
        scan->data.s.nx = image_width;
        scan->data.s.ny = image_height;
//      scan->data.s.dx = 1;
//      scan->data.s.dy = 1;
        scan->data.s.dz = 1;
        scan->data.s.rx = scan->data.s.nx*scan->data.s.dx;
        scan->data.s.ry = scan->data.s.ny*scan->data.s.dy;
        scan->data.s.rz = 256.0;
        scan->data.s.x0 = 0;
        scan->data.s.y0 = 0;
        scan->data.s.alpha = 0.;
        scan->data.display.bright = 0.;
        scan->data.display.vrange_z = 256.;
        scan->data.display.voffset_z = 0.;
        
        scan->mem2d->Resize (scan->data.s.nx, scan->data.s.ny, ZD_RGBA);

        scan->data.orgmode = SCAN_ORG_CENTER;
        scan->mem2d->data->MkXLookup (-scan->data.s.rx/2., scan->data.s.rx/2.);
        scan->mem2d->data->MkYLookup (-scan->data.s.ry/2., scan->data.s.ry/2.);

        uch *image_data = readpng_get_image(display_exponent, &image_channels, &image_rowbytes);

        uch *src;
        ulg lastrow, row;
        uch r, g, b, a;
        ulg red, green, blue;

        for (lastrow = row = 0;  row < image_height;  ++row) {
                src = image_data + row*image_rowbytes;
                if (image_channels == 3) {
                        for (int i = 0; i < image_width; ++i) {
                                red   = *src++;
                                green = *src++;
                                blue  = *src++;
                                scan->mem2d->PutDataPkt ((double)red,   i, row, 0);
                                scan->mem2d->PutDataPkt ((double)green, i, row, 1);
                                scan->mem2d->PutDataPkt ((double)blue,  i, row, 2);
                                scan->mem2d->PutDataPkt (0., i, row, 3);
                        }
                } else  /* if (image_channels == 4) */ {
                        for (int i = 0; i < image_width; ++i) {
                                r = *src++;
                                g = *src++;
                                b = *src++;
                                a = *src++;
                                scan->mem2d->PutDataPkt ((double)r, i, row, 0);
                                scan->mem2d->PutDataPkt ((double)g, i, row, 1);
                                scan->mem2d->PutDataPkt ((double)b, i, row, 2);
                                scan->mem2d->PutDataPkt ((double)a, i, row, 3);
//                                      alpha_composite(red,   r, a, bg_red);
//                                      alpha_composite(green, g, a, bg_green);
//                                      alpha_composite(blue,  b, a, bg_blue);
                        }
                }
        }
        readpng_cleanup(TRUE);
        fclose(infile);
        return status=FIO_OK; 
}

FIO_STATUS PNG_ImExportFile::Write(){
        int pcnt=0;
        mainprog_info m;
        unsigned char **rgb;

        PI_DEBUG (DBG_L2, "writing >" << name << "<");

        if (name == NULL) return FIO_NO_NAME;

        m.gamma   = 1.;
        m.width   = scan->data.s.nx;
        m.height  = scan->data.s.ny;
        m.modtime = time(NULL);
        m.infile  = NULL;
        if (! (m.outfile = fopen(name, "wb")))
                return status=FIO_OPEN_ERR;

        rgb = new unsigned char* [m.height];
        for (int i=0; i<m.height; rgb[i++] = new unsigned char[3*m.width]);



        if (scan->mem2d->GetNv() == 4){ // use direct RGB[A] from data
                int k,j;
                for (int i=0; i<m.height; ++i)
                        for (k=j=0; j<m.width; ++j){
                                *(rgb[i] + k++) = (unsigned char)scan->mem2d->GetDataPkt (j, i, 0);
                                *(rgb[i] + k++) = (unsigned char)scan->mem2d->GetDataPkt (j, i, 1);
                                *(rgb[i] + k++) = (unsigned char)scan->mem2d->GetDataPkt (j, i, 2);
                        }
        }else{

                int k,j;
                int cval;
                ifstream cpal;
                char pline[256];
                int r,g,b,nx,ny;
                double val;
                int ival;
                int maxcol=1024;
                unsigned char tgapal[1024][3];

                if (gapp->xsm->ZoomFlg & VIEW_PALETTE){
                        cpal.open(xsmres.Palette, ios::in);
                        PI_DEBUG (DBG_L2, "Using Palette: " << xsmres.Palette );
                        if(cpal.good()){
                                cpal.getline(pline, 255);
                                cpal.getline(pline, 255);
                                cpal >> nx >> ny;
                                cpal.getline(pline, 255);
                                cpal.getline(pline, 255);
                                
                                for(maxcol=min(nx, 1024), cval=0; cval<maxcol; ++cval){
                                        cpal >> r >> g >> b ;
                                        tgapal[cval][0] = r;
                                        tgapal[cval][1] = g;
                                        tgapal[cval][2] = b;
                                }
                                cpal.close();
                        } else {
                                PI_DEBUG (DBG_L2, "Using Palette failed, fallback to greyscale!" );
                                for (maxcol=256, cval=0; cval<maxcol; ++cval)
                                        tgapal[cval][2] = tgapal[cval][1] = tgapal[cval][0] = cval * 255 / maxcol; 
                        }
                }else{
                        PI_DEBUG (DBG_L2, "Using greyscale palette!" );
                        for (maxcol=256, cval=0; cval<maxcol; ++cval)
                                tgapal[cval][2] = tgapal[cval][1] = tgapal[cval][0] = cval * 255 / maxcol; 
                }
                PI_DEBUG (DBG_L2, "MaxCol#: " << maxcol );
                PI_DEBUG (DBG_L2, "VFlg:    " << scan->data.display.ViewFlg );


                // Set View-Mode Data Range and auto adapt Vcontrast/Bright
                scan->mem2d->SetDataRange(0, maxcol);
                scan->mem2d->AutoDataSkl(NULL, NULL);

                // use GetDataVMode to use the current set View-Mode (Direct, Quick, ...)
                for (int i=0; i<m.height; ++i)
                        for (k=j=0; j<m.width; ++j){
                                val = scan->mem2d->GetDataVMode (j,i);
                                ival = (int)((val >= maxcol ? maxcol-1 : val < 0 ? 0 : val) + .5);

                                *(rgb[i] + k++) = (unsigned char)tgapal[ival][0];
                                *(rgb[i] + k++) = (unsigned char)tgapal[ival][1];
                                *(rgb[i] + k++) = (unsigned char)tgapal[ival][2];
                        }
        }

        m.row_pointers = rgb;
        m.title  = "GXSM-PNG-ImExport-PlugIn";
        m.author = "Percy Zahl";
        m.desc   = "GXSM PNG export";
        m.copyright = "GPL";
        m.email   = "zahl@users.sourceforge.net";
        m.url     = "http://gxsm.sf.net";
        m.have_bg   = FALSE;
        m.have_time = FALSE;
        m.have_text = FALSE;
        m.pnmtype   = 6; // TYPE_RGB
        m.sample_depth = 8;
        m.interlaced= FALSE;

        writepng_init (&m);
        writepng_encode_image (&m);
        writepng_encode_finish (&m);
        writepng_cleanup (&m);
        fclose (m.outfile);

        for (int i=0; i<m.height; delete[] rgb[i++]);
        delete[] rgb;
        
        // start exporting -------------------------------------------
        return status=FIO_OK; 
}

// Plugin's Notify Cb's, registered to be called on file load/save to check file
// return via filepointer, it is set to Zero or passed as Zero if file has been processed!
// That's all fine, you should just change the Text Stings below...


static void png_im_export_filecheck_load_callback (gpointer data ){
        gchar **fn = (gchar**)data;
        if (*fn){
                PI_DEBUG (DBG_L2, "checking >" << *fn << "<" );

                Scan *dst = gapp->xsm->GetActiveScan();
                if(!dst){ 
                        gapp->xsm->ActivateFreeChannel();
                        dst = gapp->xsm->GetActiveScan();
                }
                PNG_ImExportFile fileobj (dst, *fn);

                FIO_STATUS ret = fileobj.Read(); 
                if (ret != FIO_OK){ 
                        // I'am responsible! (But failed)
                        if (ret != FIO_NOT_RESPONSIBLE_FOR_THAT_FILE)
                                *fn=NULL;
                        // no more data: remove allocated and unused scan now, force!
                        gapp->xsm->SetMode(-1, ID_CH_M_OFF, TRUE); 
                        PI_DEBUG (DBG_L2, "Read Error " << ((int)ret) );
                }else{
                        // got it!
                        *fn=NULL;

                        // Now update gxsm main window data fields
                        gapp->xsm->ActiveScan->GetDataSet(gapp->xsm->data);
                        gapp->spm_update_all();
                        dst->draw();
                }
        }else{
                PI_DEBUG (DBG_L2, "Skipping" << *fn << "<" );
        }
}

static void png_im_export_filecheck_save_callback (gpointer data ){
        gchar **fn = (gchar**)data;
        if (*fn){
                Scan *src;
                PI_DEBUG (DBG_L2, "Saving/(checking) >" << *fn << "<" );

                PNG_ImExportFile fileobj (src = gapp->xsm->GetActiveScan(), *fn);

                FIO_STATUS ret;
                ret = fileobj.Write(); 

                if(ret != FIO_OK){
                        // I'am responsible! (But failed)
                        if (ret != FIO_NOT_RESPONSIBLE_FOR_THAT_FILE)
                                *fn=NULL;
                        PI_DEBUG (DBG_L2, "Write Error " << ((int)ret) );
                }else{
                        // write done!
                        *fn=NULL;
                }
        }else{
                PI_DEBUG (DBG_L2, "Skipping >" << *fn << "<" );
        }
}

// Menu callback functions -- usually no need to edit

static void png_im_export_import_callback(GtkWidget *w, void *data){
        gchar **help = g_strsplit (png_im_export_pi.help, ",", 2);
        gchar *dlgid = g_strconcat (png_im_export_pi.name, "-import", NULL);
        gchar *fn = gapp->file_dialog (help[0], NULL, file_mask, NULL, dlgid);
        g_strfreev (help); 
        g_free (dlgid);
        png_im_export_filecheck_load_callback (&fn );
}

static void png_im_export_export_callback(GtkWidget *w, void *data){
        gchar **help = g_strsplit (png_im_export_pi.help, ",", 2);
        gchar *dlgid = g_strconcat (png_im_export_pi.name, "-export", NULL);
        gchar *fn = gapp->file_dialog(help[1], NULL, file_mask, NULL, dlgid);
        g_strfreev (help); 
        g_free (dlgid);
        png_im_export_filecheck_save_callback (&fn );
}

---