converter.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: converter.C
 * ========================================
 * 
 * Copyright (C) 2003 The Free Software Foundation
 *
 * Authors: Kristan Temme <etptt@users.sf.net>
 * 
 * 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: Converter 
% PlugInName: Converter
% PlugInAuthor: Kristan Temme and Thorsten Wagner
% PlugInAuthorEmail: stm@users.sf.net
% PlugInMenuPath: Tools/Converter 
% PlugInDescription
Simple file conversion utility, which converts files all kinds of data files supported by GXSM-2
% PlugInUsage
Registers itself for converting files. Just choose the right file extensions for the conversion (e.g. .nc to .top). You can also select the source and destination folder by the browse buttons.
% EndPlugInDocuSection
 * -------------------------------------------------------------------------------- 
 */


#include <gtk/gtk.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <fnmatch.h>
#include <string.h>
#include <unistd.h>

#include "config.h"
#include "gxsm/plugin.h"
#include "gxsm/dataio.h"
#include "gxsm/action_id.h"
#include "gxsm/util.h"
#include "batch.h"
#include "fileio.c"

#include "converter.h"
#include "gxsm_app.h"
#include "surface.h"

#include "unit.h"
#include "pcs.h"
#include "xsmtypes.h"

#define IMGMAXCOLORS 64
#define WSXM_MAXCHARS 1000
#define UMASK (S_IRUSR | S_IWUSR | S_IXUSR )

// Plugin Prototypes
static void converter_init (void);
static void converter_query (void);
static void converter_about (void);
static void converter_configure (void);
static void converter_cleanup (void);

static void converter_convert(GtkWidget *w, void *data);


//
// Gxsm plugin discription
//
GxsmPlugin converter_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,                   // filled in just after init() is called !!!
  "Converter",
  NULL,                      
  "Converts supported file types faster",
  "Kristan Temme and Thorsten Wagner",
  N_("_Tools/"),
  N_("Converter"),
  NULL,
  "No further info",
  NULL,          
  NULL,          
  converter_init,  
  converter_query,  
  converter_about,
  converter_configure,
  NULL,
  converter_cleanup
};

//
//Text used in the About Box
//
static const char *about_text = N_("Gxsm Converter for supported files.");
                                   
        
//
// 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 ){ 
  converter_pi.description = g_strdup_printf(N_("Gxsm converter file converter %s"), VERSION);
  return &converter_pi; 
}

//
// Query Function, installs Plugin's in the apropriate menupath
// !!!! make sure the "converter_cleanup()" function (see below) !!!!
// !!!! removes the correct menuentries !!!!
//
static void converter_query(void)
{
  static GnomeUIInfo menuinfo_Convert[] = { 
    { GNOME_APP_UI_ITEM, 
      N_("Converter"), N_("Converts supported file formats quickly"), 
      (gpointer) converter_convert, NULL,
      NULL, GNOME_APP_PIXMAP_STOCK, GNOME_STOCK_MENU_OPEN,
      0, GDK_CONTROL_MASK, NULL },
    GNOMEUIINFO_END
  };

  gnome_app_insert_menus (
          GNOME_APP(converter_pi.app->getApp()), 
          N_("Tools/"), 
          menuinfo_Convert
          );
 
  if(converter_pi.status) g_free(converter_pi.status); 
  converter_pi.status = g_strconcat (
          N_("Plugin query has attached "),
          converter_pi.name, 
          N_(": File converter is ready to use"),
          NULL);
}

//
// init-Function
//

static void converter_init(void)
{
  PI_DEBUG(DBG_L2,"converter Plugin Init");
}

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

//
// configure-Function
//
static void converter_configure(void)
{
  if(converter_pi.app)
    converter_pi.app->message("converter Plugin Configuration");
}

//
// cleanup-Function, make sure the Menustrings are matching those above!!!
//
static void converter_cleanup(void)
{
  PI_DEBUG(DBG_L2,"converter Plugin Cleanup");
  gnome_app_remove_menus (GNOME_APP (converter_pi.app->getApp()),
                          N_("Tools/Converter"), 1);
}


//Gtk+ Signal Funktion
static void converter_convert(GtkWidget *w, void *data)
{
  converterControl *Popup = new converterControl();
  Popup->run();
  PI_DEBUG(DBG_L2,"converter dialog opened");
}


// ANFANG converter

gchar *select_mask;

converter::converter() : m_converted(0)
{
        PI_DEBUG(DBG_L2,"Generating converter object!");
}


void converter::concatenate_dirs(gchar* target, const gchar* add)
{
        int len = strlen(target);
        if (len > 0 && target[len-1] != '/')
                strcat(target, "/");
        strcat(target, add);
}


void converter::create_full_path(gchar* target, const gchar* source_directory,
        const gchar* current_dir, const gchar* file)
{
        if (source_directory)
                strcpy(target, source_directory);
        else
                *target = '\0';

        if (current_dir)
                concatenate_dirs(target, current_dir);

        if (file)
                concatenate_dirs(target, file);
}


void converter::replace_suffix(gchar* target, gchar* new_suffix)
{
        int len = strlen(target);

        for (int i = len-1; i > -1; --i) {
                if (target[i] == EXT_SEP) {
                        strcpy(target+i+1, new_suffix);
                        return;
                }
        }
}


void converter::ConvertDir(converterData* work_it, const gchar* current_dir)
{
        gchar source_dir[MAX_PATH];

        create_full_path(source_dir, work_it->sourceDir, current_dir, 0);

        DIR* dir = opendir(source_dir);

        if (dir) {
                struct stat file_stat;
                dirent* current_file;
                gchar source_name[MAX_PATH];
                gchar target_name[MAX_PATH];

                while ((current_file = readdir(dir))) {
                        create_full_path(source_name, work_it->sourceDir, current_dir, 
                                current_file->d_name);
                        if (lstat(source_name, &file_stat) != -1) {
                                // go recursively in case of directories
                                if (S_ISDIR(file_stat.st_mode) && *current_file->d_name != '.')
                                {
                                        if (work_it->m_recursive) {
                                                if (work_it->m_create_subdirs) {
                                                        create_full_path(target_name, work_it->destDir,
                                                                current_dir, current_file->d_name);
                                                //      if (lstat(target_name, &file_stat) != -1
                                                //              && mkdir(target_name, S_IRUSR | S_IWUSR
                                                //                       | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP)
                                                //                       == -1)
                                                        if (mkdir(target_name, S_IRUSR | S_IWUSR
                                                                         | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP)
                                                                         == -1)
                                                        {
                                                                std::cout << "Could not create directory "
                                                                        << target_name << std::endl; 
                                                        } else
                                                                std::cout << "Create directory "
                                                                         << target_name << std::endl;
                                                }
                                                create_full_path(source_name, 0, current_dir,
                                                         current_file->d_name);
                                                ConvertDir(work_it, source_name);
                                        }
                                // otherwise check whether the file matches the mask
                                // Note: S_ISREG didn't seem to work correctly on my
                                // system - otherwise I would use it as well
                                } else if (!fnmatch(work_it->convFilter, current_file->d_name,
                                        0))
                                {
                                        create_full_path(source_name, work_it->sourceDir,
                                                current_dir, current_file->d_name);
                                        create_full_path(target_name, work_it->destDir,
                                                work_it->m_create_subdirs ? current_dir : 0, current_file->d_name);
                                        replace_suffix(target_name, work_it->writeFormat);

                                        if (!work_it->m_overwrite_target
                                                 && lstat(target_name, &file_stat) != -1)
                                        {
                                                std::cout << target_name << " already exists!"
                                                         << std::endl;
                                                continue;
                                        }

                                        ++m_converted;
                                        std::cout << "Converting file " << m_converted << ": "
                                                << source_name << std::endl;
                                        DoConvert(source_name, target_name);
                                }
                        }
                }       
        }

        closedir(dir);
}


void converter::DoConvert(gchar *pathname,gchar *outputname)
{
        if (gapp->xsm->ActivateFreeChannel()) {
                PI_DEBUG(DBG_L2,"Nc2top Error: finding Free Channel" );
                return;
        }

        gint Ch = gapp->xsm->FindChan(ID_CH_M_ACTIVE);          
 
        if ((Ch = readToAct(pathname)) < 0)
                PI_DEBUG(DBG_L2,"readToAct: Conversion of " << pathname << "failed");
                  
        else {
                if (!writeFromCh(Ch, outputname))
                        PI_DEBUG(DBG_L2,"Converted: " << pathname << " to " << outputname);
                else 
                        PI_DEBUG(DBG_L2,"writeFromCh: Conversion of " << pathname << "failed");                        
        }

        gapp->xsm->SetMode(Ch, ID_CH_M_OFF, TRUE);      
}


gint  converter::readToAct( gchar *fname){
        
  Scan   *ActiveScan = NULL;
  Dataio *Dio = NULL;
  gint ret = -1;
  
  ActiveScan = gapp->xsm->GetActiveScan();              
  ret = gapp->xsm->FindChan(ID_CH_M_ACTIVE);
  
// check if something else (no NetCDF)
 if (!(strstr(fname, ".nc") || strstr(fname, ".NC"))){
                     gapp->xsm->gnuimport (fname);
                     return ret;
                }
 else {
        if (!strncasecmp(fname+strlen(fname)-3,".nc",3))
          Dio = new NetCDF(ActiveScan, fname);          // NetCDF File
        else ret =-1; //Error: no import filter found!
          
        Dio->Read();
        if(Dio->ioStatus()){
          //Some error occured 
          ret = -1;
          }  
        delete Dio;

  ActiveScan->GetDataSet(gapp->xsm->data);
  // refresh all Parameter and draw Scan
  gapp->spm_update_all();
  ActiveScan->draw();   
        
  return  ret ;
 }              
}

gint converter::writeFromCh(gint Ch, gchar *fname)
{
        gint ret;
        
        if (!(strstr(fname, ".nc") || strstr(fname, ".NC")))
        {
                //Make sure We are using the right channel
                if (gapp->xsm->FindChan(ID_CH_M_ACTIVE) != Ch)
                        gapp->xsm->ActivateChannel(Ch);
                                                        
                ret = gapp->xsm->gnuexport (fname);
                return ret;
        } else  {
                ret = gapp->xsm->save(TRUE, fname, Ch, true);
                return ret;
        }       

        return -1; 
 }


gchar* converter::strParse(gchar* name, converterData* check)
{
        int len = strlen(name);
        gchar* fname = strdup(name);
  
        if (len > 0) {
                int index = len;
                for (; index > 0; --index) {
                        if (fname[index] == EXT_SEP)
                                break;
                }
                fname[index] = '\0';

                len = strlen(check->destDir);

                if (len > 0) {
                        if(check->destDir[len-1] != '/')
                                strcat(check->destDir, "/");
                }
                
                snprintf(retStr, MAX_PATH, "%s%s.%s", check->destDir, fname,
                        check->writeFormat);
                return retStr;
        } else
                return NULL;
}
                        
// ENDE converter

// ANFANG converterControl

gint file_error(const gchar *err_msg, const gchar *dir);

converterControl::converterControl ()
{ 
  topdata = new converterData(getenv("PWD"),getenv("PWD"),"*.nc", "top");
  XsmRescourceManager xrm("FilePathSelectionHistory","Converter");
  xrm.Get ("SourcePath",&topdata->sourceDir, getenv("PWD"));
  xrm.Get ("DestPath", &topdata->destDir, getenv("PWD"));
  xrm.Get ("InputFilter", &topdata->convFilter, "*.nc");
  xrm.Get ("OutputFilter",&topdata->writeFormat, "top");        
}


converterControl::~converterControl ()
{
  delete topdata;
}


void converterControl::run()
{
        GtkWidget *dialog;
        GtkWidget *vbox;
        GtkWidget *hbox;
        GtkWidget *VarName;
        GtkWidget *variable;
        GtkWidget *help;
  
  DlgStart();
  dialog = gnome_dialog_new(_("converter Convert"),
                                             _("Convert"),  
                                GNOME_STOCK_BUTTON_CANCEL, 
                             NULL); 
  
   gnome_dialog_set_close(GNOME_DIALOG(dialog), FALSE);
   gnome_dialog_close_hides(GNOME_DIALOG(dialog), FALSE);
   gnome_dialog_set_default(GNOME_DIALOG(dialog), 3);      
  
        vbox = gtk_vbox_new (FALSE, 0);
    gtk_widget_show (vbox);

        gtk_box_pack_start(GTK_BOX(GNOME_DIALOG(dialog)->vbox),
                     vbox, TRUE, TRUE, GNOME_PAD);


         hbox = gtk_hbox_new (FALSE, 0);
  gtk_widget_show (hbox);
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
                        
  VarName = gtk_label_new (_("Source Path"));
  gtk_widget_set_usize (VarName, 100, -1);
  gtk_widget_show (VarName);
  gtk_label_set_justify(GTK_LABEL(VarName), GTK_JUSTIFY_LEFT);
  gtk_misc_set_alignment (GTK_MISC (VarName), 0.0, 0.5);
  gtk_misc_set_padding (GTK_MISC (VarName), 5, 0);
  gtk_box_pack_start (GTK_BOX (hbox), VarName, TRUE, TRUE, 0);
        
   SrcDir = variable = gnome_file_entry_new( NULL, "Choose the source directory");
   gnome_file_entry_set_default_path( GNOME_FILE_ENTRY ( variable ), topdata->sourceDir);
   gnome_file_entry_set_directory_entry(GNOME_FILE_ENTRY (variable), TRUE);
   gnome_file_entry_set_filename (GNOME_FILE_ENTRY (variable), topdata->sourceDir);
   gtk_box_pack_start (GTK_BOX (hbox), variable, TRUE, TRUE, 0);
   gtk_widget_show(variable);

  hbox = gtk_hbox_new (FALSE, 0);
  gtk_widget_show (hbox);
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);

  VarName = gtk_label_new (_("Selection Mask"));
  gtk_widget_set_usize (VarName, 100, -1);
  gtk_widget_show (VarName);
  gtk_label_set_justify(GTK_LABEL(VarName), GTK_JUSTIFY_LEFT);
  gtk_misc_set_alignment (GTK_MISC (VarName), 0.0, 0.5);
  gtk_misc_set_padding (GTK_MISC (VarName), 5, 0);
  gtk_box_pack_start (GTK_BOX (hbox), VarName, TRUE, TRUE, 0);
  
  SrcMask = variable = gtk_entry_new ();
  gtk_widget_show (variable);
  gtk_box_pack_start (GTK_BOX (hbox), variable, TRUE, TRUE, 0);
  gtk_entry_set_text (GTK_ENTRY (variable), topdata->convFilter);

  help = gtk_button_new_with_label (_("Help"));
  gtk_widget_show (help);
  gtk_box_pack_start (GTK_BOX (hbox), help, TRUE, TRUE, 0);
  gtk_signal_connect (GTK_OBJECT (help), "clicked",
                      GTK_SIGNAL_FUNC (show_info_callback),
                      (void*)(_("Select subset of files via wildcard.")));

  hbox = gtk_hbox_new (FALSE, 0);
  gtk_widget_show (hbox);
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);

  VarName = gtk_label_new (_("Destination Path"));
  gtk_widget_set_usize (VarName, 100, -1);
  gtk_widget_show (VarName);
  gtk_label_set_justify(GTK_LABEL(VarName), GTK_JUSTIFY_LEFT);
  gtk_misc_set_alignment (GTK_MISC (VarName), 0.0, 0.5);
  gtk_misc_set_padding (GTK_MISC (VarName), 5, 0);
  gtk_box_pack_start (GTK_BOX (hbox), VarName, TRUE, TRUE, 0);

  DestDir = variable = gnome_file_entry_new( NULL, "Choose the destination directory");
  gnome_file_entry_set_default_path( GNOME_FILE_ENTRY ( variable ), topdata->destDir);
  gnome_file_entry_set_directory_entry(GNOME_FILE_ENTRY (variable), TRUE);
  gnome_file_entry_set_filename (GNOME_FILE_ENTRY (variable), topdata->destDir);
  gtk_box_pack_start (GTK_BOX (hbox), variable, TRUE, TRUE,0 );
  gtk_widget_show(variable);

  hbox = gtk_hbox_new (FALSE, 0);
  gtk_widget_show (hbox);
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);

  VarName = gtk_label_new (_("Format"));
  gtk_widget_set_usize (VarName, 100, -1);
  gtk_widget_show (VarName);
  gtk_label_set_justify(GTK_LABEL(VarName), GTK_JUSTIFY_LEFT);
  gtk_misc_set_alignment (GTK_MISC (VarName), 0.0, 0.5);
  gtk_misc_set_padding (GTK_MISC (VarName), 5, 0);
  gtk_box_pack_start (GTK_BOX (hbox), VarName, TRUE, TRUE, 0);
  
  DestMask = variable = gtk_entry_new ();
  gtk_widget_show (variable);
  gtk_box_pack_start (GTK_BOX (hbox), variable, TRUE, TRUE, 0);
  gtk_entry_set_text (GTK_ENTRY (variable), topdata->writeFormat);

  help = gtk_button_new_with_label (_("Help"));
  gtk_widget_show (help);
  gtk_box_pack_start (GTK_BOX (hbox), help, TRUE, TRUE, 0);
  gtk_signal_connect (GTK_OBJECT (help), "clicked",
                      GTK_SIGNAL_FUNC (show_info_callback),
  (void*)(_("Enter the file format suffix without any special characters")));
  
        gtk_signal_connect(GTK_OBJECT(dialog), "clicked",
                GTK_SIGNAL_FUNC(converterControl::dlg_clicked),
                this);
  
        hbox = gtk_hbox_new(FALSE, 0);
        gtk_widget_show(hbox);
        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
        GtkWidget* toggle_recursive = gtk_check_button_new_with_label("Recursive");
        
        gtk_box_pack_start(GTK_BOX (hbox), toggle_recursive, TRUE, TRUE, 0);
        gtk_widget_show(toggle_recursive);
        GtkWidget* toggle_overwrite_target = gtk_check_button_new_with_label("Overwrite Target File");
        gtk_signal_connect(GTK_OBJECT(toggle_recursive), "clicked",
                GTK_SIGNAL_FUNC(converterControl::recursive_click),
                this);
  
        gtk_box_pack_start(GTK_BOX (hbox), toggle_overwrite_target, TRUE, TRUE, 0);
        gtk_widget_show(toggle_overwrite_target);
        gtk_signal_connect(GTK_OBJECT(toggle_overwrite_target), "clicked",
                GTK_SIGNAL_FUNC(converterControl::overwrite_target_click),
                this);
  
        GtkWidget* toggle_create_subdirs = gtk_check_button_new_with_label("Create sub-directories");
        gtk_box_pack_start(GTK_BOX (hbox), toggle_create_subdirs, TRUE, TRUE, 0);
        gtk_widget_show(toggle_create_subdirs);
        gtk_signal_connect(GTK_OBJECT(toggle_create_subdirs), "clicked",
                GTK_SIGNAL_FUNC(converterControl::create_subdirs_click),
                this);
  

  gtk_widget_show(dialog);  
}


void converterControl::recursive_click(GtkWidget* widget, gpointer userdata)
{
        ((converterControl*) userdata)->topdata->m_recursive = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
}


void converterControl::overwrite_target_click(GtkWidget* widget, gpointer userdata)
{
        ((converterControl*) userdata)->topdata->m_overwrite_target = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
}


void converterControl::create_subdirs_click(GtkWidget* widget, gpointer userdata)
{
        ((converterControl*) userdata)->topdata->m_create_subdirs = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
}


void converterControl::dlg_clicked(GnomeDialog * dialog, gint button_number, converterControl *mic){

        converter *converter_obj;
        converter_obj = new converter();
  
        
  g_free(mic->topdata->sourceDir); 
  mic->topdata->sourceDir = g_strdup(gnome_file_entry_get_full_path(GNOME_FILE_ENTRY (mic->SrcDir),TRUE));
  if(mic->topdata->sourceDir == NULL && !button_number)
                if(file_error("Source directory does not exist",NULL)){
                            gnome_dialog_close(dialog); 
                                goto finish;
                }
                
  g_free(mic->topdata->convFilter); 
  mic->topdata->convFilter = g_strdup(gtk_entry_get_text (GTK_ENTRY (mic->SrcMask)));
 
  
  g_free(mic->topdata->destDir); 
  mic->topdata->destDir = g_strdup(gnome_file_entry_get_full_path(GNOME_FILE_ENTRY (mic->DestDir),FALSE));
  if(access(mic->topdata->destDir,F_OK) && !button_number)
                if(file_error("Destination directory does not exist",mic->topdata->destDir)){
                                        gnome_dialog_close(dialog); 
                                        goto finish;
            }
            
   g_free(mic->topdata->writeFormat); 
  mic->topdata->writeFormat = g_strdup(gtk_entry_get_text (GTK_ENTRY (mic->DestMask)));   
  
  
  switch(button_number){
   
    case 0: 
       gnome_dialog_close(dialog);                                                                                                                                                              
       show_info_callback(NULL, _("Converting ..."));
       converter_obj->ConvertDir(mic->topdata, 0);
        break;
   
    case 1: 
        gnome_dialog_close(dialog); 
        break;
  
  }
finish:
  XsmRescourceManager xrm("FilePathSelectionHistory","Converter");
  xrm.Put ("SourcePath", mic->topdata->sourceDir);
  xrm.Put ("DestPath", mic->topdata->destDir);
  xrm.Put ("InputFilter", mic->topdata->convFilter);
  xrm.Put ("OutputFilter", mic->topdata->writeFormat);
  mic->DlgDone();

}

gint file_error(const gchar *err_msg, const gchar *dir)
{
        GtkWidget *dialog;
 
 if(dir != NULL){       
        
        dialog = gnome_message_box_new(err_msg, GNOME_MESSAGE_BOX_QUESTION,
                                                GNOME_STOCK_BUTTON_YES,
                                                GNOME_STOCK_BUTTON_NO,
                                                NULL);
        
        if(gnome_dialog_run_and_close( GNOME_DIALOG (dialog)) == 0){
                                          if(mkdir(dir, UMASK)){
                                            PI_DEBUG(DBG_L2,"Error: creating the directory");
                                                        return 1;
                                                }
                                        return 0;       
                }
         else {
                        PI_DEBUG(DBG_L2,"Aborting ..."<< err_msg);
                        return 1;                       
              }
  }
 
 else{
                dialog = gnome_error_dialog(err_msg);
            gnome_dialog_run_and_close( GNOME_DIALOG (dialog) );
            PI_DEBUG(DBG_L2, "Aborting ... " << err_msg);
            return 1;
        }       
}
// ENDE converterControl

//ANFANG converterData

converterData :: converterData(gchar *src, gchar *dst, gchar *conv, gchar *write) : m_recursive(false), m_overwrite_target(false), m_create_subdirs(false)
{
                sourceDir   =  g_strdup(src);
                destDir     =  g_strdup(dst); 
        convFilter  =  g_strdup(conv);
        writeFormat =  g_strdup(write);
}
        
converterData :: ~converterData() 
{
                g_free(sourceDir);
                g_free(destDir);
                g_free(convFilter);
                g_free(writeFormat);
}

// ENDE converterData

---