/* LinNeighborhood
 * Copyright (c) 1999-2002 Richard Stemmer and Hans Schmid
 *
 * 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.
 */

#include <limits.h>
#include <gtk/gtk.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/stat.h>
#include <gdk/gdkkeysyms.h>
#include <gtk/gtktext.h>
#include <stdio.h>
#include <stdlib.h>
#include "gtk_dialog.h"
#include "gtk_gui.h"
#include "gtk_tree.h"
#include "preferences.h"
#include "data.h"
#include "utility.h"
#include "browsewrap.h"
#include "io.h"
#include "smbif.h"

#include "picture/neighborhood-logo.xpm"
#include "picture/add.xpm"
#include "picture/remove.xpm"
#include "picture/edit.xpm"
#include "picture/close.xpm"
#include "picture/arrow_down_button.xpm"


/*
 * Change to 1 to enable fixed width dialogs.
 * Else the width will be computed at run-time.
 */

#if 0
#define ADD_MACHINE_DIALOG_WIDTH      270 /* Add dialog. */

#define ADD_MACHINE_WIDTH_1           100

#define PREF_DIALOG_WIDTH	            420 /* Preference dialog. */

#define SCAN_TAB_WIDTH_1              200
#define PROG_TAB_WIDTH_1               90
#define MISC_TAB_WIDTH_1              110

#define USER_BROWSE_DIALOG_WIDTH      230 /* User browse dialog. */
#define USER_BROWSE_DIALOG_HEIGHT     135
#define USER_BROWSE_LABEL_WIDTH       115
#else
#define ADD_MACHINE_DIALOG_WIDTH       -1

#define ADD_MACHINE_WIDTH_1            -1

#define PREF_DIALOG_WIDTH              -1

#define SCAN_TAB_WIDTH_1               -1
#define PROG_TAB_WIDTH_1               -1
#define MISC_TAB_WIDTH_1               -1

#define USER_BROWSE_DIALOG_WIDTH       -1
#define USER_BROWSE_DIALOG_HEIGHT      -1
#define USER_BROWSE_LABEL_WIDTH        -1
#endif


/* -------------------------------- */
/* -- username + password dialog -- */
/* -------------------------------- */

static GtkWidget *user_browse_dlg = (GtkWidget*)NULL;
static GtkWidget *domain_entry;
static GtkWidget *user_entry;
static GtkWidget *password_entry;
static GtkWidget *user_browse_ok_button;
static unsigned char user_browse_with_domain;

static void user_browse_ok_callback (GtkWidget *widget, GtkWidget *dlg)
{
  BROWSE_MODE mode;

  string_ncopy(globals.domain_name, gtk_entry_get_text(GTK_ENTRY(domain_entry)), MAXGROUPNAMEL);
  string_ncopy(globals.browse_user, gtk_entry_get_text(GTK_ENTRY(user_entry)), USER_LEN);
  string_ncopy(globals.browse_password,gtk_entry_get_text(GTK_ENTRY(password_entry)), PASSWORD_LEN);
  
  if ( is_empty_string(globals.domain_name) )
    globals.domain_name[0] = 0;
  if ( is_empty_string(globals.browse_user) )
    globals.browse_user[0] = 0;
  if ( is_empty_string(globals.browse_password) )
    globals.browse_password[0] = 0;
  
  gtk_widget_destroy(dlg);
  user_browse_dlg = (GtkWidget*)NULL;
  
  is_password_once = 1;
  mode = BROWSE_MODE_USER;
  if ( user_browse_with_domain )
    mode |= BROWSE_MODE_DOMAIN;
  tree_scan_item(mode);
}

static gboolean user_browse_key_press_callback (GtkWidget *widget, GdkEventKey *event)
{
  if ( event->keyval == GDK_Return )
  {
    if ( (GTK_WINDOW(user_browse_dlg))->default_widget == user_browse_ok_button ) {
      user_browse_ok_callback(user_browse_ok_button, user_browse_dlg);
      return TRUE;
    }
  }
  return FALSE;
}

void user_browse_dialog (unsigned char with_domain)
{
  GtkWidget *vbox;
  GtkWidget *table;
  GtkWidget *label;
  GtkWidget *button;
  
  user_browse_with_domain = with_domain;

  if ( !user_browse_dlg )
  {
    user_browse_dlg = gtk_dialog_new();
    gtk_window_set_wmclass(GTK_WINDOW(user_browse_dlg), "user_browse", "LinNeighborhood");
    gtk_window_set_policy(GTK_WINDOW(user_browse_dlg), 0, 0, 0);
    gtk_window_set_title(GTK_WINDOW(user_browse_dlg), _(" Insert User"));
    gtk_signal_connect(GTK_OBJECT(user_browse_dlg), "destroy",
                  	GTK_SIGNAL_FUNC(gtk_widget_destroyed), &user_browse_dlg);
    gtk_widget_set_usize(user_browse_dlg, USER_BROWSE_DIALOG_WIDTH, USER_BROWSE_DIALOG_HEIGHT);
    gtk_widget_realize(user_browse_dlg);
    gtk_container_border_width(GTK_CONTAINER(GTK_DIALOG(user_browse_dlg)->action_area), 5);
    
    vbox = gtk_vbox_new(FALSE, 0);
    gtk_container_border_width(GTK_CONTAINER(vbox), 5);
    gtk_box_pack_start(GTK_BOX (GTK_DIALOG (user_browse_dlg)->vbox),
                      	vbox, TRUE, TRUE, 0);
    gtk_widget_show(vbox);
    
    table = gtk_table_new(3, 2, FALSE);
    gtk_table_set_col_spacing( GTK_TABLE(table), 0, 10);
    gtk_table_set_row_spacings( GTK_TABLE(table), 3);
    
    label = gtk_label_new(_("domain:"));
    gtk_misc_set_alignment(GTK_MISC(label), 0.5, 0.5);
    gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
    gtk_widget_show(label);
    label = gtk_label_new(_("username:"));
    gtk_misc_set_alignment(GTK_MISC(label), 0.5, 0.5);
    gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2);
    gtk_widget_show(label);
    label = gtk_label_new(_("password:"));
    gtk_misc_set_alignment(GTK_MISC(label), 0.5, 0.5);
    gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 2, 3);
    gtk_widget_show(label);
    
    domain_entry = gtk_entry_new_with_max_length(MAXGROUPNAMEL);
    gtk_entry_set_text(GTK_ENTRY(domain_entry), globals.domain_name);
    gtk_widget_set_usize(domain_entry, 120, -1);
    gtk_widget_set_sensitive(domain_entry, with_domain);
    gtk_signal_connect_object(GTK_OBJECT(domain_entry), "key_press_event",
                  	GTK_SIGNAL_FUNC(user_browse_key_press_callback), NULL);
    gtk_table_attach_defaults(GTK_TABLE(table), domain_entry, 1, 2, 0, 1);
    gtk_widget_show(domain_entry);
    user_entry = gtk_entry_new_with_max_length(USER_LEN);
    gtk_entry_set_text(GTK_ENTRY(user_entry), globals.browse_user);
    gtk_widget_set_usize(user_entry, 120, -1);
    gtk_signal_connect_object(GTK_OBJECT(user_entry), "key_press_event",
                  	GTK_SIGNAL_FUNC(user_browse_key_press_callback), NULL);
    gtk_table_attach_defaults(GTK_TABLE(table), user_entry, 1, 2, 1, 2);
    gtk_widget_show(user_entry);
    password_entry = gtk_entry_new_with_max_length(PASSWORD_LEN);
    gtk_entry_set_visibility(GTK_ENTRY(password_entry), 0);	
    gtk_entry_set_text(GTK_ENTRY(password_entry), globals.browse_password);
    gtk_widget_set_usize(password_entry, 120, -1);
    gtk_signal_connect_object(GTK_OBJECT(password_entry), "key_press_event",
                  	GTK_SIGNAL_FUNC(user_browse_key_press_callback), NULL);
    gtk_table_attach_defaults(GTK_TABLE(table), password_entry, 1, 2, 2, 3);
    gtk_widget_show(password_entry);
    
    gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 0);
    gtk_widget_show(table);
    
    user_browse_ok_button = gtk_button_new_with_label(_("OK"));
    GTK_WIDGET_SET_FLAGS(user_browse_ok_button, GTK_CAN_DEFAULT);
    gtk_signal_connect(GTK_OBJECT(user_browse_ok_button), "clicked",
                  	GTK_SIGNAL_FUNC(user_browse_ok_callback), GTK_OBJECT(user_browse_dlg));
    gtk_box_pack_start(GTK_BOX (GTK_DIALOG (user_browse_dlg)->action_area),
                    	user_browse_ok_button, TRUE, TRUE, 0);
    gtk_widget_grab_default(user_browse_ok_button);
    gtk_widget_show(user_browse_ok_button);
    
    button = gtk_button_new_with_label(_("Cancel"));
    GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
    gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
                  	GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(user_browse_dlg));
    gtk_box_pack_start(GTK_BOX (GTK_DIALOG (user_browse_dlg)->action_area),
                    	button, TRUE, TRUE, 0);
    gtk_widget_show(button);
    
    gtk_widget_grab_focus(user_entry);
  }
    
  if ( !GTK_WIDGET_VISIBLE(user_browse_dlg) )
    gtk_widget_show(user_browse_dlg);
}

/* ------------------ */
/* -- about dialog -- */
/* ------------------ */


void about_dialog (void)
{
  static GtkWidget *window = (GtkWidget*)NULL;
  GtkWidget *button,*pixmapwid;
  static GdkPixmap *pixmap = (GdkPixmap*)NULL;
  static GdkBitmap *mask;
  GtkStyle *style;
  GdkGC *gc;
  GdkFont *font;
  GdkColor color;
  char versionsstr[32];
  int tw;
  GtkWidget *vbox;

  string_ncopy(versionsstr, _("Version "), 31);
  string_ncat(versionsstr, VERSION, 31);
  
  if (!window )
  {
    window = gtk_dialog_new();
    gtk_window_set_wmclass(GTK_WINDOW(window), "about", "LinNeighborhood");
    gtk_window_set_policy(GTK_WINDOW(window), 0, 0, 0);
    gtk_window_set_title(GTK_WINDOW(window), _(" About LinNeighborhood"));
    gtk_signal_connect(GTK_OBJECT(window), "destroy",
                    GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window);
    gtk_container_border_width(GTK_CONTAINER(GTK_DIALOG(window)->action_area), 7);
    style = gtk_widget_get_style(window );
    if (!pixmap)
    {
      pixmap = gdk_pixmap_create_from_xpm_d( main_window->window,  &mask,
                                           &style->bg[GTK_STATE_NORMAL],
                                           (gchar **)neighborhood_logo_xpm );
      color.red =   0 * (65535/255);
      color.green = 0 * (65535/255);
      color.blue =  0 * (65535/255);
      color.pixel = 0;
      gc = gdk_gc_new(pixmap); 
      gdk_color_alloc(gtk_widget_get_colormap(main_window),&color);   
      gdk_gc_set_foreground(gc,&color);
      font = gdk_fontset_load ("-*-times-bold-r-*-*-*-120-*-*-*-*-*-*");
      tw = gdk_text_width(font ?: gtk_style_get_font(window->style), versionsstr, strlen(versionsstr));
      gdk_draw_text(pixmap, font ?: gtk_style_get_font(window->style),gc,178-(tw/2),115,
                                                versionsstr,strlen(versionsstr));
      if ( font ) gdk_font_unref(font);
      gdk_gc_unref(gc); 
    }
    
    vbox = gtk_vbox_new(FALSE, 0);
    gtk_container_border_width(GTK_CONTAINER(vbox), 5);
    gtk_box_pack_start(GTK_BOX (GTK_DIALOG(window)->vbox), vbox, TRUE, TRUE, 0);
    gtk_widget_show(vbox);
    
    /* a pixmap widget to contain the pixmap */
    pixmapwid = gtk_pixmap_new( pixmap, mask );
    gtk_widget_show( pixmapwid );
    gtk_box_pack_start(GTK_BOX(vbox), pixmapwid , FALSE, FALSE, 0);

    /*label = gtk_entry_new();
    gtk_entry_set_text(GTK_ENTRY(label), "http://www.bnro.de/~schmidjo");
    gtk_entry_set_editable(GTK_ENTRY(label), 0);
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox),label,TRUE,FALSE,0);
    gtk_widget_show(label);*/
    
    button = gtk_button_new_with_label(_("Close"));
    gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
                    GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(window));
    GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
    gtk_box_pack_start(GTK_BOX (GTK_DIALOG (window)->action_area),
                  	button, TRUE, TRUE, 0);
    gtk_widget_grab_default(button);
    gtk_widget_show(button);
  
  }
  if ( !GTK_WIDGET_VISIBLE(window) )
    gtk_widget_show(window);
  else
    gtk_widget_destroy(window);
}

/* ----------------------- */
/* -- log window dialog -- */
/* ----------------------- */

static unsigned char do_logging = 0;
static GtkWidget *log_window_dlg = (GtkWidget*)NULL;
static GtkWidget *log_text;
static GdkFont *log_text_font;

static void log_window_close_callback (GtkButton *button)
{
  if ( log_window_dlg )
    gtk_widget_destroy(log_window_dlg);
  log_window_dlg = (GtkWidget*)NULL;
  do_logging = 0;
  status_set_logging_text();
}

static void log_window_clear_callback (GtkWidget *widget, GtkWidget *dlg)
{
  guint len;
  
  len = gtk_text_get_length(GTK_TEXT(log_text));
  gtk_text_backward_delete(GTK_TEXT(log_text), len);
}

static unsigned char log_window_visible (void)
{
  return ( log_window_dlg != NULL ) ? 1 : 0;
}

unsigned char log_window_active (void)
{
  return do_logging;
}

void log_window_toggle (void)
{
  do_logging = ( do_logging ) ? 0 : 1;
}

void log_window_dialog (void)
{
  GtkWidget *button;
  GtkWidget *table;
  GtkWidget *vscrollbar;

  if ( !(log_window_visible()) )
  {
    log_window_dlg = gtk_dialog_new();
    gtk_window_set_wmclass(GTK_WINDOW(log_window_dlg), "log", "LinNeighborhood");
    gtk_window_set_title(GTK_WINDOW(log_window_dlg), _(" Log Window"));
    gtk_signal_connect(GTK_OBJECT(log_window_dlg), "destroy",
                    GTK_SIGNAL_FUNC(gtk_widget_destroyed), &log_window_dlg);
    gtk_widget_set_usize(log_window_dlg, 500, 400);
  
    table = gtk_table_new(1, 2, FALSE);

    log_text = gtk_text_new(NULL, NULL);
    gtk_text_set_editable(GTK_TEXT(log_text), 0);
    gtk_text_set_word_wrap(GTK_TEXT(log_text), 1);
    gtk_table_attach(GTK_TABLE(table), log_text, 0, 1, 0, 1,
                    	GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0);
    gtk_widget_show(log_text);
                      
    vscrollbar = gtk_vscrollbar_new(GTK_TEXT(log_text)->vadj);
    gtk_table_attach(GTK_TABLE(table), vscrollbar, 1, 2, 0, 1,
                    	GTK_FILL, GTK_EXPAND | GTK_FILL | GTK_SHRINK, 0, 0);
    gtk_widget_show(vscrollbar);
    gtk_box_pack_start( GTK_BOX(GTK_DIALOG (log_window_dlg)->vbox), table, TRUE, TRUE, 0);


    gtk_widget_show(table);
    
    gtk_container_border_width(GTK_CONTAINER(GTK_DIALOG(log_window_dlg)->action_area), 3);

    button = gtk_button_new_with_label(_("Clear"));
    gtk_signal_connect_object(GTK_OBJECT(button), "released",
                  	GTK_SIGNAL_FUNC(log_window_clear_callback), GTK_OBJECT(log_window_dlg));
    GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
    gtk_box_pack_start(GTK_BOX (GTK_DIALOG (log_window_dlg)->action_area),
                  	button, TRUE, TRUE, 0);
    gtk_widget_show(button);
    
    button = gtk_button_new_with_label(_("Close"));
    gtk_signal_connect(GTK_OBJECT(button), "released",
                      GTK_SIGNAL_FUNC(log_window_close_callback), NULL);
    GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
    gtk_box_pack_start(GTK_BOX (GTK_DIALOG (log_window_dlg)->action_area),
                  	button, TRUE, TRUE, 0);
    gtk_widget_grab_default(button);
    gtk_widget_show(button);
    
    log_text_font = gdk_fontset_load("-misc-fixed-medium-r-*-*-13-120-75-75-c-60-*-*");
  }
  if ( !GTK_WIDGET_VISIBLE(log_window_dlg) )
    gtk_widget_show(log_window_dlg);
}

void insert_log_string (char * log, unsigned char add_linefeed)
{
  if ( do_logging )
  {
    if ( !(log_window_visible()) )
      log_window_dialog();
    
    gtk_text_insert(GTK_TEXT(log_text), log_text_font, NULL, NULL, log, strlen(log));
    if ( add_linefeed )
    {
      gtk_text_insert(GTK_TEXT(log_text), log_text_font, NULL, NULL, "\n", 1);
    }
  }
}

/* ------------------------------ */
/* -- preferred machine dialog -- */
/* ------------------------------ */


static GtkWidget *pref_machine_dlg = NULL;
static GtkWidget *machine_entry;
static GtkWidget *group_entry;
static GtkWidget *ip_entry;
static GtkWidget *query_label;

static char add_machine_prefname[MAXMACHNAMEL+1];    /* previous name if edited */

static PREF_MACHINE_DIALOG_STRUCT prefstruct;

void LookupByName_done (char *machine_name, char *group_name,
                        char *ipaddr, GetSMBStateType state)
{
  switch ( state )
  {
    case SMB_STATE_OK:
        gtk_entry_set_text(GTK_ENTRY(machine_entry), machine_name);
        gtk_entry_set_text(GTK_ENTRY(group_entry), group_name);
        gtk_entry_set_text(GTK_ENTRY(ip_entry), ipaddr);
        gtk_label_set_text(GTK_LABEL(query_label), _("query host...done"));
        break;

    case SMB_STATE_SMBERR:
        gtk_label_set_text(GTK_LABEL(query_label), _("query error !"));
        break;

    case SMB_STATE_EXEERR:
        gtk_label_set_text(GTK_LABEL(query_label), _("samba execution error !"));
        break;
  }
}

void LookupByIP_done (char *ipaddr, char *machine_name,
                      char *group_name, GetSMBStateType state)
{
  switch ( state )
  {
    case SMB_STATE_OK:
        gtk_entry_set_text(GTK_ENTRY(machine_entry), machine_name);
        gtk_entry_set_text(GTK_ENTRY(group_entry), group_name);
        gtk_entry_set_text(GTK_ENTRY(ip_entry), ipaddr);
        gtk_label_set_text(GTK_LABEL(query_label), _("query host...done"));
        break;

    case SMB_STATE_SMBERR:
        gtk_label_set_text(GTK_LABEL(query_label), _("query error !"));
        break;

    case SMB_STATE_EXEERR:
        gtk_label_set_text(GTK_LABEL(query_label), _("samba execution error !"));
        break;
  }
}

/* -- destroy the dialog properly -- */
static void add_machine_dialog_destroy (GtkWidget *widget, GtkWidget *dlg)
{
  gpointer *ptr;

  if ( pref_machine_dlg )
  {
    ptr = gtk_object_get_user_data(GTK_OBJECT(pref_machine_dlg));
    if ( ptr )
      g_free(ptr);
    gtk_widget_destroy(pref_machine_dlg);
  }
  pref_machine_dlg = NULL;
}

/* -- ok, add/change the favourite host -- */
static void add_machine_ok (void)
{
  host_struct *host;

  add_machine_dialog_destroy(NULL, NULL);
  
  if ( is_empty_string(prefstruct.prefhost.machine) )
  {
    string_ncopy(prefstruct.prefhost.machine, prefstruct.prefhost.ip, MAXMACHNAMEL);
  }
  
  if ( prefstruct.is_edit )
  {
    /* --- favourite host was edited --- */
    host = host_list_search_by_name(add_machine_prefname);
    /* has machine name changed ? */
    if ( !compare_smb_machinename(add_machine_prefname, prefstruct.prefhost.machine) )
    {
      /* yes, new name already exists ? */
      if ( (host_list_search_by_name(prefstruct.prefhost.machine)) != NULL )
      {
        ShowMessageBox(_("Error"),
                       _("Machine already exists in list !"));
        return;
      }
    }
    /* name is ok */
    if ( host != NULL )
    {
      /* change properties */
      string_ncopy(host->name, prefstruct.prefhost.machine, MAXMACHNAMEL);
      string_ncopy(host->group, prefstruct.prefhost.group, MAXGROUPNAMEL);
      string_ncopy(host->ipaddr, prefstruct.prefhost.ip, MAXIPL);
      notify_host_change();
    }
  }
  else
  {
    if ( !is_empty_string(prefstruct.prefhost.machine) ||
         !is_empty_string(prefstruct.prefhost.ip) )
    {
      /* --- add new favourite host --- */
      data_hosts_add(prefstruct.prefhost.machine,
                     prefstruct.prefhost.group,
                     prefstruct.prefhost.ip,
                     host_local);
    }
  }
}

/* -- callback function for MessageDlg -- */
static void add_machine_msgdlg_callback (unsigned int button)
{
  /* continue pressed ? */
  if ( button == CONTINUE_B )
  {
    add_machine_ok();
  }
}

/* -- callback for OK-Button -- */
static void add_machine_ok_callback (GtkWidget *widget, GtkWidget *dlg)
{
  unsigned char ok;
  unsigned char error = 0;
  unsigned char no_name = 0;
  PREF_MACHINE_DIALOG_STRUCT *ptr;

  ptr = (PREF_MACHINE_DIALOG_STRUCT*)gtk_object_get_user_data(GTK_OBJECT(dlg));
  memcpy(&prefstruct, ptr, sizeof(PREF_MACHINE_DIALOG_STRUCT));
  
  string_ncopy(prefstruct.prefhost.machine, gtk_entry_get_text(GTK_ENTRY(machine_entry)),MAXMACHNAMEL);
  string_ncopy(prefstruct.prefhost.group,gtk_entry_get_text(GTK_ENTRY(group_entry)),MAXGROUPNAMEL);
  string_ncopy(prefstruct.prefhost.ip, gtk_entry_get_text(GTK_ENTRY(ip_entry)),MAXIPL);

  /* test name string */
  ok = is_empty_string(prefstruct.prefhost.machine);
  if ( ok )
  {
    strcpy(prefstruct.prefhost.machine, "");
    no_name = 1;
  }
  /* test group string */
  ok = is_empty_string(prefstruct.prefhost.group);
  if ( ok )
  {
    strcpy(prefstruct.prefhost.group, "");
  }
  /* test ip string */
  ok = is_empty_string(prefstruct.prefhost.ip);
  if ( ok )
  {
    strcpy(prefstruct.prefhost.ip, "");
  }
  else
  {
    if ( !is_ipv4_address(prefstruct.prefhost.ip) )
    {
      error = 1;
      ShowMessageBox(_("Error"),
                     _("Error in IP string !"));
    }
  }
  
  if ( !error )
  {
    if ( no_name )
    {
      error = 1;
      ShowMessageDialog(_("Warning"),
                        _("No machine name !\n"
                          "There may be browse problems."),
                        CONTINUE_B | ABORT_B,
                        add_machine_msgdlg_callback);
    }
  }
  
  /* if !error -> close dialog */
  if ( !error )
  {
    add_machine_ok();
  }
}

/* -- callback for Query-Button -- */
static void add_machine_query_callback (GtkWidget *widget, GtkWidget *dlg)
{
  PREF_MACHINE_DIALOG_STRUCT *pstruct;

  pstruct = (PREF_MACHINE_DIALOG_STRUCT*)gtk_object_get_user_data(GTK_OBJECT(dlg));
  string_ncopy(pstruct->prefhost.machine, gtk_entry_get_text(GTK_ENTRY(machine_entry)),MAXMACHNAMEL);
  string_ncopy(pstruct->prefhost.group,gtk_entry_get_text(GTK_ENTRY(group_entry)),MAXGROUPNAMEL);
  string_ncopy(pstruct->prefhost.ip, gtk_entry_get_text(GTK_ENTRY(ip_entry)),MAXIPL);

  gtk_label_set_text(GTK_LABEL(query_label), _("query host..."));
  if ( !is_empty_string(pstruct->prefhost.ip) )
  {
    if ( is_ipv4_address(pstruct->prefhost.ip) )
    {
      pstruct->query_ok = 1;
      LookupByIP(pstruct->prefhost.ip);
    }
    else
    {
      gtk_label_set_text(GTK_LABEL(query_label), _("error in ip string !"));
      gtk_widget_grab_focus(ip_entry);
    }
  }
  else
  {
    if ( !is_empty_string(pstruct->prefhost.machine) )
    {
      pstruct->query_ok = 1;
      if ( is_empty_string(pref.v.wins_server) )
        LookupByName(pstruct->prefhost.machine, "");
      else
        LookupByName(pstruct->prefhost.machine, pref.v.wins_server);
    }
    else
    {
      gtk_label_set_text(GTK_LABEL(query_label), _("enter name or ip address !"));
      gtk_widget_grab_focus(machine_entry);
    }
  }
}

static void add_machine_dialog (PREF_MACHINE_DIALOG_STRUCT *pstruct)
{
  GtkWidget *vbox;
  GtkWidget *table;
  GtkWidget *label;
  GtkWidget *button;
  
  if ( !pref_machine_dlg )
  {
    pref_machine_dlg = gtk_dialog_new();
    gtk_object_set_user_data(GTK_OBJECT(pref_machine_dlg), pstruct);
    gtk_window_set_wmclass(GTK_WINDOW(pref_machine_dlg), "add_machine", "LinNeighborhood");
    gtk_window_set_modal(GTK_WINDOW(pref_machine_dlg), TRUE);
    gtk_window_set_policy(GTK_WINDOW(pref_machine_dlg), 0, 0, 0);
    gtk_window_set_title(GTK_WINDOW(pref_machine_dlg), _(" Add Machine"));
    gtk_signal_connect(GTK_OBJECT(pref_machine_dlg), "destroy",
                    GTK_SIGNAL_FUNC(gtk_widget_destroyed), &pref_machine_dlg);
    gtk_widget_set_usize(pref_machine_dlg, ADD_MACHINE_DIALOG_WIDTH, 155);
    gtk_widget_realize(pref_machine_dlg);
    gtk_container_border_width(GTK_CONTAINER(GTK_DIALOG(pref_machine_dlg)->action_area), 5);
    
    vbox = gtk_vbox_new(FALSE, 0);
    gtk_container_border_width(GTK_CONTAINER(vbox), 5);
    gtk_box_pack_start(GTK_BOX (GTK_DIALOG (pref_machine_dlg)->vbox),
                      	vbox, TRUE, TRUE, 0);
    gtk_widget_show(vbox);
    
    table = gtk_table_new(4, 2, FALSE);
    gtk_table_set_col_spacing(GTK_TABLE(table), 0, 12);
    
    label = gtk_label_new(_("machine:"));
    gtk_widget_set_usize(label, ADD_MACHINE_WIDTH_1, -1);
    gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5);
    gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
    gtk_widget_show(label);
    label = gtk_label_new(_("group:"));
    gtk_widget_set_usize(label, ADD_MACHINE_WIDTH_1, -1);
    gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5);
    gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2);
    gtk_widget_show(label);
    label = gtk_label_new(_("IP-address:"));
    gtk_widget_set_usize(label, ADD_MACHINE_WIDTH_1, -1);
    gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5);
    gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 2, 3);
    gtk_widget_show(label);
    label = gtk_label_new(_("query status:"));
    gtk_widget_set_usize(label, ADD_MACHINE_WIDTH_1, -1);
    gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5);
    gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 3, 4);
    gtk_widget_show(label);
    
    machine_entry = gtk_entry_new_with_max_length(MAXMACHNAMEL);
    gtk_entry_set_text(GTK_ENTRY(machine_entry), pstruct->prefhost.machine);
    gtk_widget_set_usize(machine_entry, 150, -1);
    gtk_table_attach_defaults(GTK_TABLE(table), machine_entry, 1, 2, 0, 1);
    gtk_widget_show(machine_entry);
    group_entry = gtk_entry_new_with_max_length(MAXGROUPNAMEL);
    gtk_entry_set_text(GTK_ENTRY(group_entry), pstruct->prefhost.group);
    gtk_widget_set_usize(group_entry, 150, -1);
    gtk_table_attach_defaults(GTK_TABLE(table), group_entry, 1, 2, 1, 2);
    gtk_widget_show(group_entry);
    ip_entry = gtk_entry_new_with_max_length(MAXIPL);
    gtk_widget_set_usize(ip_entry, 150, -1);
    gtk_entry_set_text(GTK_ENTRY(ip_entry), pstruct->prefhost.ip);
    gtk_table_attach_defaults(GTK_TABLE(table), ip_entry, 1, 2, 2, 3);
    gtk_widget_show(ip_entry);
    
    query_label = gtk_label_new("");
    gtk_misc_set_alignment(GTK_MISC(query_label), 0.0, 0.5);
    gtk_table_attach_defaults(GTK_TABLE(table), query_label, 1, 2, 3, 4);
    gtk_widget_show(query_label);

    gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 0);
    gtk_widget_show(table);
    
    button = gtk_button_new_with_label(_("Query"));
    GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
    gtk_signal_connect(GTK_OBJECT(button), "clicked",
                  	GTK_SIGNAL_FUNC(add_machine_query_callback), GTK_OBJECT(pref_machine_dlg));
    gtk_box_pack_start(GTK_BOX (GTK_DIALOG (pref_machine_dlg)->action_area),
                    	button, TRUE, TRUE, 0);
    gtk_widget_grab_default(button);
    gtk_widget_show(button);
    
    button = gtk_button_new_with_label(_("OK"));
    GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
    gtk_signal_connect(GTK_OBJECT(button), "clicked",
                  	GTK_SIGNAL_FUNC(add_machine_ok_callback), GTK_OBJECT(pref_machine_dlg));
    gtk_box_pack_start(GTK_BOX (GTK_DIALOG (pref_machine_dlg)->action_area),
                    	button, TRUE, TRUE, 0);
    gtk_widget_show(button);
    
    button = gtk_button_new_with_label(_("Cancel"));
    GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
    gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
                  	GTK_SIGNAL_FUNC(add_machine_dialog_destroy), GTK_OBJECT(pref_machine_dlg));
    gtk_box_pack_start(GTK_BOX (GTK_DIALOG (pref_machine_dlg)->action_area),
                    	button, TRUE, TRUE, 0);
    gtk_widget_show(button);
    
    gtk_widget_grab_focus(machine_entry);
  }
    
  if ( !GTK_WIDGET_VISIBLE(pref_machine_dlg) )
    gtk_widget_show(pref_machine_dlg);
}

void enter_pref_machine (void)
{
  PREF_MACHINE_DIALOG_STRUCT *pstruct;

  pstruct = g_malloc(sizeof(PREF_MACHINE_DIALOG_STRUCT));
  pstruct->is_edit = 0;
  pstruct->pref_machine = NULL;
  pstruct->query_ok = 0;
  strcpy(pstruct->prefhost.machine, cempty);
  strcpy(pstruct->prefhost.group, cempty);
  strcpy(pstruct->prefhost.ip, cempty);
  
  add_machine_dialog(pstruct);
}

void edit_pref_machine (GtkTreeItem *item, char *name, char *group, char *ip)
{
  PREF_MACHINE_DIALOG_STRUCT *pstruct;

  /* save previous name */
  string_ncopy(add_machine_prefname, name, MAXMACHNAMEL);
  
  pstruct = g_malloc(sizeof(PREF_MACHINE_DIALOG_STRUCT));
  pstruct->is_edit = 1;
  pstruct->pref_machine = item;
  pstruct->query_ok = 0;
  string_ncopy(pstruct->prefhost.machine, name, MAXMACHNAMEL);
  string_ncopy(pstruct->prefhost.group, group, MAXGROUPNAMEL);
  string_ncopy(pstruct->prefhost.ip, ip, MAXIPL);
  
  add_machine_dialog(pstruct);
}

/* ------------------------- */
/* -- machine info dialog -- */
/* ------------------------- */

#define MACHINE_INFO_WIDTH              150

static char info[MAXCOMMENTL+3];

void machine_info_dialog (char *name, MACHINEINFO_STRUCT *machineinfo)
{
  GtkWidget *machine_info_dlg;
  GtkWidget *table;
  GtkWidget *label;
  GtkWidget *button;
  GtkWidget *frame;
  char ndstring[] = " n.d.";
  
  machine_info_dlg = gtk_dialog_new();
  gtk_window_set_wmclass(GTK_WINDOW(machine_info_dlg), "machine_info", "LinNeighborhood");
  gtk_window_set_modal(GTK_WINDOW(machine_info_dlg), TRUE);
  gtk_window_set_policy(GTK_WINDOW(machine_info_dlg), 0, 0, 0);
  gtk_window_set_title(GTK_WINDOW(machine_info_dlg), _(" Machine Info"));
  gtk_signal_connect(GTK_OBJECT(machine_info_dlg), "destroy",
                  	GTK_SIGNAL_FUNC(gtk_widget_destroyed), &machine_info_dlg);
  gtk_widget_realize(machine_info_dlg);
  gtk_container_border_width(GTK_CONTAINER(GTK_DIALOG(machine_info_dlg)->action_area), 5);
    
  table = gtk_table_new(5, 2, FALSE);
  gtk_container_set_border_width(GTK_CONTAINER(table), 10);
  gtk_table_set_col_spacing(GTK_TABLE(table), 0, 18);
  /* bug in gtk+ ? */
  gtk_table_set_row_spacings(GTK_TABLE(table), 5);
    
  label = gtk_label_new(_("Name:"));
  gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5);
  gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
  gtk_widget_show(label);

  label = gtk_label_new(_("Domain:"));
  gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5);
  gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2);
  gtk_widget_show(label);

  label = gtk_label_new(_("OS:"));
  gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5);
  gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 2, 3);
  gtk_widget_show(label);

  label = gtk_label_new(_("Server:"));
  gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5);
  gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 3, 4);
  gtk_widget_show(label);

  label = gtk_label_new(_("IP Address:"));
  gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5);
  gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 4, 5);
  gtk_widget_show(label);
    
  strcpy(info, " ");
  string_ncat(info, name, MAXCOMMENTL+1);

  frame = gtk_frame_new(NULL);
  label = gtk_label_new(info);
  gtk_widget_set_usize(label, MACHINE_INFO_WIDTH, -1);
  gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  gtk_container_add(GTK_CONTAINER(frame), label);
  gtk_widget_show(label);
  gtk_table_attach_defaults(GTK_TABLE(table), frame, 1, 2, 0, 1);
  gtk_widget_show(frame);

  if ( is_empty_string(machineinfo->Domain) )
    strcpy(info, ndstring);
  else
  {
    strcpy(info, " ");
    string_ncat(info, machineinfo->Domain, MAXCOMMENTL+1);
  }
  
  frame = gtk_frame_new(NULL);
  gtk_table_attach_defaults(GTK_TABLE(table), frame, 1, 2, 1, 2);
  gtk_widget_show(frame);
  label = gtk_label_new(info);
  gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  gtk_container_add(GTK_CONTAINER(frame), label);
  gtk_widget_show(label);

  if ( is_empty_string(machineinfo->OS) )
    strcpy(info, ndstring);
  else
  {
    strcpy(info, " ");
    string_ncat(info, machineinfo->OS, MAXCOMMENTL+1);
  }

  frame = gtk_frame_new(NULL);
  gtk_table_attach_defaults(GTK_TABLE(table), frame, 1, 2, 2, 3);
  gtk_widget_show(frame);
  label = gtk_label_new(info);
  gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  gtk_container_add(GTK_CONTAINER(frame), label);
  gtk_widget_show(label);

  if ( is_empty_string(machineinfo->Server) )
    strcpy(info, ndstring);
  else
  {
    strcpy(info, " ");
    string_ncat(info, machineinfo->Server, MAXCOMMENTL+1);
  }

  frame = gtk_frame_new(NULL);
  gtk_table_attach_defaults(GTK_TABLE(table), frame, 1, 2, 3, 4);
  gtk_widget_show(frame);
  label = gtk_label_new(info);
  gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  gtk_container_add(GTK_CONTAINER(frame), label);
  gtk_widget_show(label);

  if ( is_empty_string(machineinfo->ipaddr) )
    strcpy(info, ndstring);
  else
  {
    strcpy(info, " ");
    string_ncat(info, machineinfo->ipaddr, MAXIPL+1);
  }

  frame = gtk_frame_new(NULL);
  gtk_table_attach_defaults(GTK_TABLE(table), frame, 1, 2, 4, 5);
  gtk_widget_show(frame);
  label = gtk_label_new(info);
  gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  gtk_container_add(GTK_CONTAINER(frame), label);
  gtk_widget_show(label);
    
  gtk_box_pack_start(GTK_BOX (GTK_DIALOG (machine_info_dlg)->vbox),
                                      table, FALSE, TRUE, 0);
  gtk_widget_show(table);
    
  button = gtk_button_new_with_label(_("Close"));
  GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
                  	GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(machine_info_dlg));
  gtk_box_pack_start(GTK_BOX (GTK_DIALOG (machine_info_dlg)->action_area),
                    	button, TRUE, TRUE, 0);
  gtk_widget_grab_default(button);
  gtk_widget_show(button);
    
  gtk_widget_show(machine_info_dlg);
}

/* ------------------------------------------------------------------------ */

/* --------------------------- */
/* -- master browser dialog -- */
/* --------------------------- */

static GtkWidget *mb_clist;
static gint focus_row;
static void master_browser_data_change_callback (data_notify_struct *notify);

static char master_browser_prefname[MAXMACHNAMEL+1];    /* previous name if edited */

static void master_browser_delete_all (void)
{
  gtk_clist_clear(GTK_CLIST(mb_clist));
}

/* -- callback functions for Dialog(s) -- */

static void add_mb_txtdlg_callback(char *input)
{
  if ( !is_empty_string(input) )
  {
    data_master_add(input, master_browser_local);
  }
}

static void remove_mb_msgdlg_callback (unsigned int button)
{
  char *master;

  /* "Yes" pressed ? */
  if ( button == YES_B )
  {
    gtk_clist_get_text(GTK_CLIST(mb_clist), focus_row, 0, &master);
    data_master_delete(master);
  }
}

static void replace_mb_txtdlg_callback(char *input)
{
  master_struct *master;
  
  master = master_list_search_by_name(master_browser_prefname);
  /* has machine name changed ? */
  if ( !compare_smb_machinename(master_browser_prefname, input) )
  {
    /* yes, new name already exists ? */
    if ( (master_list_search_by_name(input)) != NULL )
    {
      ShowMessageBox(_("Error"),
                     _("Machine already exists in list !"));
      return;
    }
  }
  /* name is ok */
  if ( master != NULL )
  {
    /* change properties */
    string_ncopy(master->name, input, MAXMACHNAMEL);
    notify_master_change();
  }
}

/* -- callbacks for dialog buttons -- */

static void mb_add_callback(GtkWidget *widget, gpointer data)
{
  TextInputDialog(_("Add Master"),
                  _("Enter Master Browser:"),
                  "",
                  MAXMACHNAMEL,
                  200, 110,
                  add_mb_txtdlg_callback);
}

static void mb_remove_callback (GtkWidget *widget, gpointer data)
{
  char *text;
  
  if ( GTK_CLIST(mb_clist)->selection )
  {
    if ( gtk_clist_get_text(GTK_CLIST(mb_clist), GTK_CLIST(mb_clist)->focus_row, 0, &text) )
    {
      focus_row = GTK_CLIST(mb_clist)->focus_row;

      ShowMessageDialog(_("Warning"),
                        _("Remove Master Browser ?"),
                        YES_B | NO_B,
                        remove_mb_msgdlg_callback);
    }
  }
}

static void mb_edit_callback (GtkWidget *widget, gpointer data)
{
  char *text;

  if ( GTK_CLIST(mb_clist)->selection )
  {
    if ( gtk_clist_get_text(GTK_CLIST(mb_clist), GTK_CLIST(mb_clist)->focus_row, 0, &text) )
    {
      focus_row = GTK_CLIST(mb_clist)->focus_row;
      string_ncopy(master_browser_prefname, text, MAXMACHNAMEL);
      
      TextInputDialog(_("Edit Master"),
                      _("Edit Master Browser:"),
                      text,
                      MAXMACHNAMEL,
                      200,110,
                      replace_mb_txtdlg_callback);
    }
  }
}

static void mb_close_callback(GtkWidget *widget, GtkWidget *dlg)
{
  notify_delete_callback(master_browser_data_change_callback);
  gtk_widget_destroy(dlg);
}

static gint mb_press_event (GtkWidget *widget, GdkEventButton *event,
                                  	gpointer data)
{
  return 0;
}

static gint mb_release_event (GtkWidget *widget, GdkEventButton *event,
                                    	gpointer data)
{
  return 0;
}

static void master_browser_edit_insert_enumerate (master_struct *master, gpointer data)
{
  GtkCList *clist;
  char *row[1];
  
  clist = GTK_CLIST(data);
  if ( (master != NULL) && (clist != NULL) )
  {
    row[0] = master->name;
    gtk_clist_append(clist, row);
  }
}

static void master_browser_retrigger (void)
{
  master_browser_delete_all();
  /* enumerate + insert all master browsers */
  master_list_enumerate(master_browser_edit_insert_enumerate, (gpointer)(mb_clist));
}

static void master_browser_data_change_callback (data_notify_struct *notify)
{
  switch ( notify->dt )
  {
    case dt_master:
        master_browser_retrigger();
        break;
    
    default:
        break;
  }
}

void master_browser_dialog ()
{
  GtkWidget *mb_dlg;
  GtkWidget *vbox;
  GtkWidget *toolbar;
  GtkWidget *icon_add;
  GtkWidget *icon_remove;
  GtkWidget *icon_edit;
  GtkWidget *icon_close;
  GtkWidget *clist_win;
  
  mb_dlg = gtk_window_new(GTK_WINDOW_POPUP);
  gtk_window_set_wmclass(GTK_WINDOW(mb_dlg), "master_browser", "LinNeighborhood");
  gtk_window_set_modal(GTK_WINDOW(mb_dlg), TRUE);
  gtk_window_set_policy(GTK_WINDOW(mb_dlg), 0, 0, 0);
  gtk_window_set_title(GTK_WINDOW(mb_dlg), _(" Master Browsers"));
  gtk_signal_connect(GTK_OBJECT(mb_dlg), "destroy",
                  	GTK_SIGNAL_FUNC(mb_close_callback), mb_dlg);
  gtk_widget_set_usize(mb_dlg, 350, 220);
  gtk_widget_realize(mb_dlg);
  
  /* main vbox */
  vbox = gtk_vbox_new(FALSE, 0);
  gtk_container_add( GTK_CONTAINER(mb_dlg), vbox);
  gtk_widget_show(vbox);
  
  /* button toolbar */
  toolbar = gtk_toolbar_new();
  gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL);
  gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH);

  gtk_box_pack_start( GTK_BOX(vbox), toolbar, FALSE, TRUE, 0);
  gtk_widget_show(toolbar);

  icon_add = new_pixmap(mb_dlg, add_xpm);
  gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), _("Add"), _("Add Master Browser"), "",
                           icon_add, GTK_SIGNAL_FUNC(mb_add_callback), NULL);

  icon_remove = new_pixmap(mb_dlg, remove_xpm);
  gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), _("  Remove  "), _("Remove Master Browser"), "",
                           icon_remove, GTK_SIGNAL_FUNC(mb_remove_callback), NULL);

  icon_edit = new_pixmap(mb_dlg, edit_xpm);
  gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), _("Edit"), _("Edit Master Browser"), "",
                           icon_edit, GTK_SIGNAL_FUNC(mb_edit_callback), NULL);

  icon_close = new_pixmap(mb_dlg, close_xpm);
  gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), _("Close"), _("Close Dialog"), "",
                           icon_close, GTK_SIGNAL_FUNC(mb_close_callback), GTK_OBJECT(mb_dlg));

  set_toolbar_tooltip_color(GTK_TOOLBAR(toolbar));
  
  /* scrolled win with CList within */
  clist_win = gtk_scrolled_window_new(NULL, NULL);
  gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(clist_win),
                                 GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
  gtk_box_pack_start( GTK_BOX(vbox), clist_win, TRUE, TRUE, 0);
  gtk_widget_show(clist_win);
  
  mb_clist = gtk_clist_new(1);
  gtk_clist_set_column_title(GTK_CLIST(mb_clist), 0, _(" Name"));
  gtk_clist_column_titles_show(GTK_CLIST(mb_clist));
  gtk_clist_set_selection_mode( GTK_CLIST(mb_clist), GTK_SELECTION_SINGLE);
  gtk_clist_column_titles_passive( GTK_CLIST(mb_clist) );
  gtk_signal_connect(GTK_OBJECT(mb_clist), "button_press_event",
                     GTK_SIGNAL_FUNC(mb_press_event), NULL);
  gtk_signal_connect(GTK_OBJECT(mb_clist), "button_release_event",
                     GTK_SIGNAL_FUNC(mb_release_event), NULL);
  gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(clist_win), mb_clist);
  gtk_widget_show(mb_clist);
  
  /* enumerate + insert all master browsers */
  master_list_enumerate(master_browser_edit_insert_enumerate, (gpointer)(mb_clist));
  
  gtk_widget_set_uposition (GTK_WIDGET(mb_dlg), 120, 100);
  gtk_widget_show(mb_dlg);

  notify_add_callback(master_browser_data_change_callback);
}

/* ------------------------------------------------------------------------ */

/* ---------------------------------------- */
/* -- browse entire network image dialog -- */
/* ---------------------------------------- */

static GtkWidget *network_browse_dlg = NULL;

static GtkWidget *ni_user_checkbox;
static GtkWidget *ni_password_entry;
static GtkWidget *ni_user_entry;
static GtkWidget *network_browse_ok_button;

static void network_image_ok_callback (GtkWidget *widget, GtkWidget *dlg)
{
  BROWSE_MODE mode;

  mode = BROWSE_MODE_NONE;
  if ( GTK_TOGGLE_BUTTON(ni_user_checkbox)->active )
  {
    string_ncopy(globals.browse_user, gtk_entry_get_text(GTK_ENTRY(ni_user_entry)), USER_LEN);
    string_ncopy(globals.browse_password,gtk_entry_get_text(GTK_ENTRY(ni_password_entry)), PASSWORD_LEN);
    mode |= BROWSE_MODE_USER;
  }
  
  gtk_widget_destroy(dlg);
  network_browse_dlg = NULL;
  
  browse_network(mode);
}

static gboolean network_image_key_press_callback (GtkWidget *widget, GdkEventKey *event)
{
  if ( event->keyval == GDK_Return )
  {
    if ( (GTK_WINDOW(network_browse_dlg))->default_widget == network_browse_ok_button ) {
      network_image_ok_callback(network_browse_ok_button, network_browse_dlg);
      return TRUE;
    }
  }
  return FALSE;
}

static void ni_user_checkbox_toggled(GtkToggleButton *button)
{
  gtk_widget_set_sensitive(ni_password_entry, button->active);
  gtk_widget_set_sensitive(ni_user_entry, button->active);
}

void browse_network_image_dialog (void)
{
  GtkWidget *vbox;
  GtkWidget *table;
  GtkWidget *label;
  GtkWidget *separator;
  GtkWidget *button;
  
  if ( !network_browse_dlg )
  {
    network_browse_dlg = gtk_dialog_new();
    gtk_window_set_wmclass(GTK_WINDOW(network_browse_dlg), "network_browse", "LinNeighborhood");
    gtk_window_set_policy(GTK_WINDOW(network_browse_dlg), 0, 0, 0);
    gtk_window_set_title(GTK_WINDOW(network_browse_dlg), _(" Entire Network Browse"));
    gtk_signal_connect(GTK_OBJECT(network_browse_dlg), "destroy",
                  	GTK_SIGNAL_FUNC(gtk_widget_destroyed), &network_browse_dlg);
    gtk_widget_realize(network_browse_dlg);
    gtk_container_border_width(GTK_CONTAINER(GTK_DIALOG(network_browse_dlg)->action_area), 5);
    
    vbox = gtk_vbox_new(FALSE, 0);
    gtk_container_border_width(GTK_CONTAINER(vbox), 5);
    gtk_box_pack_start(GTK_BOX (GTK_DIALOG (network_browse_dlg)->vbox),
                      	vbox, TRUE, TRUE, 0);
    gtk_widget_show(vbox);
    
    label = gtk_label_new(_("You are to browse the entire network for all workgroups, "
                          "machines and shares exported by these machines. This may "
                          "cause some network traffic."));
    gtk_widget_set_usize(label, 230, -1);
    gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER);
    gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
    gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);
    gtk_widget_show(label);
    
    separator = gtk_hseparator_new();
    gtk_box_pack_start(GTK_BOX(vbox), separator, FALSE, TRUE, 2);
    gtk_widget_show(separator);
    
    ni_user_checkbox = gtk_check_button_new_with_label(_("Browse as user"));
    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(ni_user_checkbox), 0);
    gtk_signal_connect(GTK_OBJECT(ni_user_checkbox), "toggled",
                  	GTK_SIGNAL_FUNC(ni_user_checkbox_toggled), NULL);
    gtk_box_pack_start(GTK_BOX(vbox), ni_user_checkbox, TRUE, TRUE, 3);
    gtk_widget_show(ni_user_checkbox);
    
    table = gtk_table_new(2, 2, FALSE);
    gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, TRUE, 0);
    gtk_table_set_col_spacing( GTK_TABLE(table), 0, 5);
    gtk_widget_show(table);
    
    label = gtk_label_new(_(" username:"));
    gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
    gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1,
                    	GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_EXPAND, 0, 0);
    gtk_widget_show(label);
    
    ni_user_entry = gtk_entry_new_with_max_length(MASTER_LEN-1);
    gtk_entry_set_text(GTK_ENTRY(ni_user_entry), globals.browse_user);
    gtk_signal_connect_object(GTK_OBJECT(ni_user_entry), "key_press_event",
                  	GTK_SIGNAL_FUNC(network_image_key_press_callback), NULL);
    gtk_widget_set_sensitive(ni_user_entry, 0);
    gtk_table_attach_defaults(GTK_TABLE(table), ni_user_entry, 1, 2, 0, 1);
    gtk_widget_show(ni_user_entry);
    
    label = gtk_label_new(_(" password:"));
    gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
    gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2,
                    	GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_EXPAND, 0, 0);
    gtk_widget_show(label);

    ni_password_entry = gtk_entry_new_with_max_length(MASTER_LEN-1);
    gtk_entry_set_visibility(GTK_ENTRY(ni_password_entry), 0);	
    gtk_entry_set_text(GTK_ENTRY(ni_password_entry), globals.browse_password);
    gtk_signal_connect_object(GTK_OBJECT(ni_password_entry), "key_press_event",
                  	GTK_SIGNAL_FUNC(network_image_key_press_callback), NULL);
    gtk_widget_set_sensitive(ni_password_entry, 0);
    gtk_table_attach_defaults(GTK_TABLE(table), ni_password_entry, 1, 2, 1, 2);
    gtk_widget_show(ni_password_entry);
    
    network_browse_ok_button = gtk_button_new_with_label(_("OK"));
    GTK_WIDGET_SET_FLAGS(network_browse_ok_button, GTK_CAN_DEFAULT);
    gtk_signal_connect(GTK_OBJECT(network_browse_ok_button), "clicked",
                  	GTK_SIGNAL_FUNC(network_image_ok_callback), GTK_OBJECT(network_browse_dlg));
    gtk_box_pack_start(GTK_BOX (GTK_DIALOG (network_browse_dlg)->action_area),
                    	network_browse_ok_button, TRUE, TRUE, 0);
    gtk_widget_grab_default(network_browse_ok_button);
    gtk_widget_show(network_browse_ok_button);
    
    button = gtk_button_new_with_label(_("Cancel"));
    GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
    gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
                  	GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(network_browse_dlg));
    gtk_box_pack_start(GTK_BOX (GTK_DIALOG (network_browse_dlg)->action_area),
                    	button, TRUE, TRUE, 0);
    gtk_widget_show(button);
    
    gtk_widget_grab_focus(ni_user_entry);
  }
  
  if ( !GTK_WIDGET_VISIBLE(network_browse_dlg) )
    gtk_widget_show(network_browse_dlg);
}

/* --------------------------------- */
/* -- export network image dialog -- */
/* --------------------------------- */

static GtkWidget *network_image_dialog;
static char network_image_filename[PATH_LEN+1];

static void network_image_msgdlg_callback (unsigned int button)
{
  /* abort ? */
  if ( button == NO_B )
    return;

  network_image_export(network_image_filename);
}

static void export_networkimage_ok_callback (GtkWidget *widget)
{
  string_ncopy(network_image_filename, gtk_file_selection_get_filename(GTK_FILE_SELECTION(network_image_dialog)), PATH_LEN);
  
  if ( file_exist(network_image_filename) )
  {
    ShowMessageDialog(_("Warning"),
                      _("File exists, overwrite ?"),
                      YES_B | NO_B,
                      network_image_msgdlg_callback);
  }
  else
  {
    network_image_msgdlg_callback(0);
  }
  gtk_widget_destroy(widget);
}

static void export_networkimage_cancel_callback (GtkWidget *widget)
{
  gtk_widget_destroy(widget);
}

void export_network_image_dialog (void)
{
  network_image_dialog = gtk_file_selection_new(_("Export Network Image"));
  gtk_window_set_modal(GTK_WINDOW(network_image_dialog), TRUE);
  gtk_file_selection_set_filename(GTK_FILE_SELECTION(network_image_dialog), SMBNETWORK_FILE);
  gtk_signal_connect_object(GTK_OBJECT(GTK_FILE_SELECTION(network_image_dialog)->ok_button),
           "clicked", (GtkSignalFunc)export_networkimage_ok_callback, GTK_OBJECT(network_image_dialog));
  gtk_signal_connect_object(GTK_OBJECT(GTK_FILE_SELECTION(network_image_dialog)->cancel_button),
           "clicked", (GtkSignalFunc)export_networkimage_cancel_callback, GTK_OBJECT(network_image_dialog));
  gtk_widget_show(network_image_dialog);
}

/* ------------------------------------------------------------------------------------- */

/* ------------------------ */
/* -- preferences dialog -- */
/* ------------------------ */

static GtkWidget *preferences_dlg = NULL;
static GtkWidget *quick_browse_checkbox;
static GtkWidget *startup_browse_checkbox;
static GtkWidget *user_scan_checkbox;
static GtkWidget *group_name_entry;
static GtkWidget *master_browser_checkbox;
static GtkWidget *master_browser_entry;
static GtkWidget *master_browser_button;
static GtkWidget *wins_server_checkbox;
static GtkWidget *wins_server_entry;
static GtkWidget *group_userscan_checkbox;
static GtkWidget *groups_userscan_checkbox;
static GtkWidget *password_once_checkbox;
static GtkWidget *group_browse_checkbox;
static GtkWidget *use_group_checkbox;
static GtkWidget *smbclient_entry;
static GtkWidget *nmblookup_entry;
static GtkWidget *smbmount_entry;
static GtkWidget *smbumount_entry;
static GtkWidget *smbmount_204_radio;
static GtkWidget *smbmount_205_radio;
static GtkWidget *smbmount_206_radio;
static GtkWidget *root_mnt_checkbox;
static GtkWidget *root_mnt_entry;
static GtkWidget *replace_space_mount_checkbox;
static GtkWidget *mount_default_no_dialog_checkbox;
static GtkWidget *memorize_mount_checkbox;
static GtkWidget *delete_mountpoints_checkbox;
static GtkWidget *default_user_entry;
static GtkWidget *default_password_checkbox;
static GtkWidget *default_password_entry;
static GtkWidget *run_fm_checkbox;
static GtkWidget *run_fm_combo;
static GtkWidget *copy_fm_button;
static GtkWidget *run_fm_entry;
static GtkWidget *use_smb_port_checkbox;
static GtkWidget *smb_port_entry;

static void preferences_dialog_set_bool (unsigned char *done_change, unsigned char value, unsigned char *old_value)
{
  if ( value != *old_value )
  {
    *old_value = value;
    *done_change = 1;
  }
}

static void preferences_dialog_set_string (unsigned char *done_change, const char *value, char **old_value, size_t maxlen)
{
  static char ctemp[256];
  char *ptemp;
  
  if ( maxlen > 255 )
    maxlen = 255;
  ptemp = ctemp;
  string_ncopy(ptemp, value, maxlen);
  string_trim(&ptemp);
  if ( strcmp(ptemp, *old_value) != 0 )
  {
    string_ncopy(*old_value, ptemp, maxlen);
    *done_change = 1;
  }
}

static void preferences_dialog_set_integer (unsigned char *done_change, const char *value_string, int *old_value)
{
  int value;
  char *ptemp;
  
  value = (int)strtol(value_string, &ptemp, 10);
  
  if ( *ptemp == 0 )
  {
    if ( value != *old_value )
    {
      *old_value = value;
      *done_change = 1;
    }
  }
}

static void preferences_scan_dialog (void)
{
  SMBMOUNT temp_version;
  char *ptemp;

  preferences_dialog_set_bool(&(pref.b.quick_browse),
          GTK_TOGGLE_BUTTON(quick_browse_checkbox)->active, &(pref.v.quick_browse));
  preferences_dialog_set_bool(&(pref.b.startup_browse),
          GTK_TOGGLE_BUTTON(startup_browse_checkbox)->active, &(pref.v.startup_browse));
  preferences_dialog_set_bool(&(pref.b.shares_scan_user),
          GTK_TOGGLE_BUTTON(user_scan_checkbox)->active, &(pref.v.shares_scan_user));
  preferences_dialog_set_bool(&(pref.b.machines_scan_user),
          GTK_TOGGLE_BUTTON(group_userscan_checkbox)->active, &(pref.v.machines_scan_user));
  preferences_dialog_set_bool(&(pref.b.groups_scan_user),
          GTK_TOGGLE_BUTTON(groups_userscan_checkbox)->active, &(pref.v.groups_scan_user));
  preferences_dialog_set_bool(&(pref.b.password_once),
          GTK_TOGGLE_BUTTON(password_once_checkbox)->active, &(pref.v.password_once));
  ptemp = pref.v.workgroup;
  preferences_dialog_set_string(&(pref.b.workgroup),
          gtk_entry_get_text(GTK_ENTRY(group_name_entry)), &ptemp, MAXGROUPNAMEL);
  preferences_dialog_set_bool(&(pref.b.master_browser_scan),
          GTK_TOGGLE_BUTTON(master_browser_checkbox)->active, &(pref.v.master_browser_scan));
  ptemp = pref.v.master;
  preferences_dialog_set_string(&(pref.b.master),
          gtk_entry_get_text(GTK_ENTRY(master_browser_entry)), &ptemp, MAXMACHNAMEL);
  preferences_dialog_set_bool(&(pref.b.wins_server_scan),
          GTK_TOGGLE_BUTTON(wins_server_checkbox)->active, &(pref.v.wins_server_scan));
  preferences_dialog_set_bool(&(pref.b.use_group_browse),
          GTK_TOGGLE_BUTTON(group_browse_checkbox)->active, &(pref.v.use_group_browse));
  preferences_dialog_set_bool(&(pref.b.use_group_mount),
          GTK_TOGGLE_BUTTON(use_group_checkbox)->active, &(pref.v.use_group_mount));
  preferences_dialog_set_bool(&(pref.b.use_smb_port),
          GTK_TOGGLE_BUTTON(use_smb_port_checkbox)->active, &(pref.v.use_smb_port));
  preferences_dialog_set_integer(&(pref.b.smb_port),
          gtk_entry_get_text(GTK_ENTRY(smb_port_entry)), &(pref.v.smb_port));
  ptemp = pref.v.wins_server;
  preferences_dialog_set_string(&(pref.b.wins_server),
          gtk_entry_get_text(GTK_ENTRY(wins_server_entry)), &ptemp, MAXMACHNAMEL);
  ptemp = pref.v.smbclient_exe;
  preferences_dialog_set_string(&(pref.b.smbclient_exe),
          gtk_entry_get_text(GTK_ENTRY(smbclient_entry)), &ptemp, PATH_LEN);
  ptemp = pref.v.nmblookup_exe;
  preferences_dialog_set_string(&(pref.b.nmblookup_exe),
          gtk_entry_get_text(GTK_ENTRY(nmblookup_entry)), &ptemp, PATH_LEN);
  ptemp = pref.v.smbmount_exe;
  preferences_dialog_set_string(&(pref.b.smbmount_exe),
          gtk_entry_get_text(GTK_ENTRY(smbmount_entry)), &ptemp, PATH_LEN);
  ptemp = pref.v.smbumount_exe;
  preferences_dialog_set_string(&(pref.b.smbumount_exe),
          gtk_entry_get_text(GTK_ENTRY(smbumount_entry)), &ptemp, PATH_LEN);

  if ( GTK_TOGGLE_BUTTON(smbmount_204_radio)->active )
    temp_version = SMBMOUNT_204;
  else if ( GTK_TOGGLE_BUTTON(smbmount_205_radio)->active )
    temp_version = SMBMOUNT_205;
  else if ( GTK_TOGGLE_BUTTON(smbmount_206_radio)->active )
    temp_version = SMBMOUNT_206;
  else
    temp_version = SMBMOUNT_206;
  if ( temp_version != pref.v.smbmount_version )
  {
    pref.v.smbmount_version = temp_version;
    pref.b.smbmount_version = 1;
  }

  preferences_dialog_set_bool(&(pref.b.root_mnt_enable),
          GTK_TOGGLE_BUTTON(root_mnt_checkbox)->active, &(pref.v.root_mnt_enable));
  ptemp = pref.v.root_mnt_dir;
  preferences_dialog_set_string(&(pref.b.root_mnt_dir),
          gtk_entry_get_text(GTK_ENTRY(root_mnt_entry)), &ptemp, PATH_LEN);
  preferences_dialog_set_bool(&(pref.b.replace_space_mount),
          GTK_TOGGLE_BUTTON(replace_space_mount_checkbox)->active, &(pref.v.replace_space_mount));
  preferences_dialog_set_bool(&(pref.b.mount_default_no_dialog),
          GTK_TOGGLE_BUTTON(mount_default_no_dialog_checkbox)->active, &(pref.v.mount_default_no_dialog));
  preferences_dialog_set_bool(&(pref.b.memorize_mounts),
          GTK_TOGGLE_BUTTON(memorize_mount_checkbox)->active, &(pref.v.memorize_mounts));
  preferences_dialog_set_bool(&(pref.b.delete_mountpoints),
          GTK_TOGGLE_BUTTON(delete_mountpoints_checkbox)->active, &(pref.v.delete_mountpoints));
  ptemp = pref.v.default_user;
  preferences_dialog_set_string(&(pref.b.default_user),
          gtk_entry_get_text(GTK_ENTRY(default_user_entry)), &ptemp, USER_LEN);
  preferences_dialog_set_bool(&(pref.b.save_default_password),
          GTK_TOGGLE_BUTTON(default_password_checkbox)->active, &(pref.v.save_default_password));
  if ( pref.v.save_default_password )
  {
    string_ncopy(globals.default_password, gtk_entry_get_text(GTK_ENTRY(default_password_entry)), PASSWORD_LEN);
  }
  else
  {
    globals.default_password[0] = 0;
  }
  preferences_dialog_set_bool(&(pref.b.run_file_manager),
          GTK_TOGGLE_BUTTON(run_fm_checkbox)->active, &(pref.v.run_file_manager));
  ptemp = pref.v.filemanager_exe;
  preferences_dialog_set_string(&(pref.b.filemanager_exe),
          gtk_entry_get_text(GTK_ENTRY(run_fm_entry)), &ptemp, PATH_LEN);
}

static void preferences_ok_callback (GtkWidget *widget, GtkWidget *dlg)
{
  preferences_scan_dialog();
  status_set_logging_text();
  
  gtk_widget_destroy(dlg);
  preferences_dlg = NULL;
}

static void preferences_save_callback (GtkWidget *widget, GtkWidget *dlg)
{
  preferences_scan_dialog();
  
  preferences_save(&pref);
}

/* ---------- */

static int preferences_argument_count;

static void preferences_cmd_argument_txtdlg_callback (char *input)
{
  char *target_string;
  unsigned char *target_boolean;
  
  switch ( preferences_argument_count )
  {
    case 1:
        target_string = pref.v.smbclient_arg;
        target_boolean = &(pref.b.smbclient_arg);
        break;
    case 2:
        target_string = pref.v.nmblookup_arg;
        target_boolean = &(pref.b.nmblookup_arg);
        break;
    case 3:
        target_string = pref.v.smbmount_arg;
        target_boolean = &(pref.b.smbmount_arg);
        break;
    case 4:
        target_string = pref.v.smbumount_arg;
        target_boolean = &(pref.b.smbumount_arg);
        break;
    default:
        return;
  }
    
  if ( !is_empty_string(input) )
  {
    /* set the argument string */
    string_ncopy(target_string, input, ARG_LEN);
    *target_boolean = 1;
  }
  else
  {
    /* empty string, clear field */
    target_string[0] = 0;
    *target_boolean = 0;
  }
}

static void preferences_cmd_argument_callback (GtkWidget *widget, gpointer *data)
{
  const char *header;
  char *old_value;

  preferences_argument_count = (int)data;
  
  switch ( preferences_argument_count )
  {
    case 1:
        header = "smbclient";
        old_value = pref.v.smbclient_arg;
        break;
    case 2:
        header = "nmblookup";
        old_value = pref.v.nmblookup_arg;
        break;
    case 3:
        header = "smbmount";
        old_value = pref.v.smbmount_arg;
        break;
    case 4:
        header = "smbumount";
        old_value = pref.v.smbumount_arg;
        break;
    default:
        return;
  }

  TextInputDialog(header,
                  _("Enter additional arguments:"),
                  old_value,
                  ARG_LEN,
                  250, 120,
                  preferences_cmd_argument_txtdlg_callback);
}

/* ---------- */

static void master_browser_toggled (GtkToggleButton *button)
{
  gtk_widget_set_sensitive(master_browser_entry, button->active);
}

static void use_smb_port_toggled (GtkToggleButton *button)
{
  gtk_widget_set_sensitive(smb_port_entry, button->active);
}

static void wins_server_toggled (GtkToggleButton *button)
{
  gtk_widget_set_sensitive(wins_server_entry, button->active);
}

static void user_scan_toggled (GtkToggleButton *button)
{
  gtk_widget_set_sensitive(password_once_checkbox, button->active);
  gtk_widget_set_sensitive(group_userscan_checkbox, button->active);
  gtk_widget_set_sensitive(groups_userscan_checkbox, button->active);
}

static void root_mnt_toggled (GtkToggleButton *button)
{
  gtk_widget_set_sensitive(root_mnt_entry, button->active);
  gtk_widget_set_sensitive(replace_space_mount_checkbox, button->active);
  gtk_widget_set_sensitive(mount_default_no_dialog_checkbox, button->active);
}

static void default_password_toggled (GtkToggleButton *button)
{
  gtk_widget_set_sensitive(default_password_entry, button->active);
}

static void run_fm_toggled (GtkToggleButton *button)
{
  gtk_widget_set_sensitive(run_fm_entry, button->active);
  gtk_widget_set_sensitive(copy_fm_button, button->active);
  gtk_widget_set_sensitive(run_fm_combo, button->active);
}

static void copy_fm_pressed (GtkWidget *widget)
{
  GtkWidget *entry;
  const char *text;
  const char *command;
  char *commstring;
  int len;
  
  entry = GTK_COMBO(run_fm_combo)->entry;
  if ( entry )
  {
    text = gtk_entry_get_text(GTK_ENTRY(entry));
    command = strchr(text, '\"');
    if ( command )
    {
      len = strlen(command);
      command++;
      commstring = g_malloc(len+1);
      string_ncopy(commstring, command, len-2);
      gtk_entry_set_text(GTK_ENTRY(run_fm_entry), commstring);
      g_free(commstring);
    }
  }
}

void preferences_dialog (void)
{
  GtkWidget *notebook;
  GtkWidget *tablabel;
  GtkWidget *frame;
  GtkWidget *frame_vbox;
  GtkWidget *frame_hbox;
  GtkWidget *table;
  GtkWidget *button;
  GtkWidget *label;
  GtkWidget *entry;
  GtkWidget *separator;
  GList *items;
  GdkBitmap *mask;
  GdkPixmap *pixmap_data;
  GtkWidget *pixmap_widget;
  char ctemp[32];
  
  if ( !preferences_dlg )
  {
    preferences_dlg = gtk_dialog_new();
    gtk_window_set_wmclass(GTK_WINDOW(preferences_dlg), "preferences", "LinNeighborhood");
    gtk_window_set_policy(GTK_WINDOW(preferences_dlg), 0, 0, 0);
    gtk_window_set_title(GTK_WINDOW(preferences_dlg), _("Preferences"));
    gtk_signal_connect(GTK_OBJECT(preferences_dlg), "destroy",
                  	GTK_SIGNAL_FUNC(gtk_widget_destroyed), &preferences_dlg);
    gtk_container_border_width(GTK_CONTAINER(GTK_DIALOG(preferences_dlg)->action_area), 5);
    
    notebook = gtk_notebook_new();
    gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_TOP);
    gtk_box_pack_start(GTK_BOX (GTK_DIALOG (preferences_dlg)->vbox),
                      	notebook, TRUE, TRUE, 0);
    gtk_widget_show(notebook);

    /* --------------------------------------------------------------------- */
    
    tablabel = gtk_label_new(_(" Scan "));
    frame = gtk_frame_new(_(" Scan Preferences "));
    gtk_container_border_width(GTK_CONTAINER(frame), 3);
    gtk_widget_set_usize(frame, PREF_DIALOG_WIDTH, -1);
    gtk_notebook_append_page(GTK_NOTEBOOK(notebook), frame, tablabel);
    gtk_widget_show(frame);
    
    frame_vbox = gtk_vbox_new(FALSE, 0);
    gtk_container_border_width(GTK_CONTAINER(frame_vbox), 5);
    gtk_container_add(GTK_CONTAINER(frame), frame_vbox);
    gtk_widget_show(frame_vbox);
    
    table = gtk_table_new(4, 2, FALSE);
    gtk_box_pack_start(GTK_BOX(frame_vbox), table, FALSE, TRUE, 0);
    gtk_table_set_col_spacing( GTK_TABLE(table), 0, 5);
    gtk_widget_show(table);
    
    label = gtk_label_new(_("Workgroup :"));
    gtk_widget_set_usize(label, SCAN_TAB_WIDTH_1, -1);
    gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
    gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
    gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1,
                    	GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_EXPAND, 0, 0);
    gtk_widget_show(label);
    
    group_name_entry = gtk_entry_new_with_max_length(MASTER_LEN-1);
    gtk_entry_set_text(GTK_ENTRY(group_name_entry), pref.v.workgroup);
    gtk_table_attach_defaults(GTK_TABLE(table), group_name_entry, 1, 2, 0, 1);
    gtk_widget_show(group_name_entry);

    master_browser_checkbox = gtk_check_button_new_with_label(_("Primary master browser :"));
    gtk_widget_set_usize(master_browser_checkbox, SCAN_TAB_WIDTH_1, -1);
    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(master_browser_checkbox), pref.v.master_browser_scan);
    gtk_signal_connect(GTK_OBJECT(master_browser_checkbox), "toggled",
                  	GTK_SIGNAL_FUNC(master_browser_toggled), NULL);
    gtk_table_attach(GTK_TABLE(table), master_browser_checkbox, 0, 1, 1, 2,
                    	GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_EXPAND, 0, 0);
    gtk_widget_show(master_browser_checkbox);
    
    master_browser_entry = gtk_entry_new_with_max_length(MASTER_LEN-1);
    gtk_entry_set_text(GTK_ENTRY(master_browser_entry), pref.v.master);
    gtk_widget_set_sensitive(master_browser_entry, pref.v.master_browser_scan);
    gtk_table_attach_defaults(GTK_TABLE(table),
					master_browser_entry, 1, 2, 1, 2);
    gtk_widget_show(master_browser_entry);

    wins_server_checkbox = gtk_check_button_new_with_label(_("WINS server :"));
    gtk_widget_set_usize(wins_server_checkbox, SCAN_TAB_WIDTH_1, -1);
    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(wins_server_checkbox), pref.v.wins_server_scan);
    gtk_signal_connect(GTK_OBJECT(wins_server_checkbox), "toggled",
                  	GTK_SIGNAL_FUNC(wins_server_toggled), NULL);
    gtk_table_attach(GTK_TABLE(table), wins_server_checkbox, 0, 1, 2, 3,
                    	GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_EXPAND, 0, 0);
    gtk_widget_show(wins_server_checkbox);
    
    wins_server_entry = gtk_entry_new_with_max_length(MASTER_LEN-1);
    gtk_entry_set_text(GTK_ENTRY(wins_server_entry), pref.v.wins_server);
    gtk_widget_set_sensitive(wins_server_entry, pref.v.wins_server_scan);
    gtk_table_attach_defaults(GTK_TABLE(table),
					wins_server_entry, 1, 2, 2, 3);
    gtk_widget_show(wins_server_entry);
    
    label = gtk_label_new(_("Additional master browsers :"));
    gtk_widget_set_usize(label, SCAN_TAB_WIDTH_1, -1);
    gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
    gtk_table_attach(GTK_TABLE(table), label, 0, 1, 3, 4,
                    	GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_EXPAND, 0, 0);
    gtk_widget_show(label);
    
    master_browser_button = gtk_button_new_with_label(_("Edit Master Browser List"));
    gtk_signal_connect(GTK_OBJECT(master_browser_button), "clicked",
                  	GTK_SIGNAL_FUNC(master_browser_dialog), NULL);
    gtk_table_attach_defaults(GTK_TABLE(table),
					master_browser_button, 1, 2, 3, 4);
    gtk_widget_show(master_browser_button);
    
    separator = gtk_hseparator_new();
    gtk_box_pack_start(GTK_BOX(frame_vbox), separator, FALSE, TRUE, 2);
    gtk_widget_show(separator);

    frame_hbox = gtk_hbox_new(TRUE, 0);
    gtk_box_pack_start(GTK_BOX(frame_vbox), frame_hbox, FALSE, TRUE, 0);
    gtk_widget_show(frame_hbox);
    
    user_scan_checkbox = gtk_check_button_new_with_label(_("Always scan as user"));
    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(user_scan_checkbox), pref.v.shares_scan_user);
    gtk_signal_connect(GTK_OBJECT(user_scan_checkbox), "toggled",
                  	GTK_SIGNAL_FUNC(user_scan_toggled), NULL);
    gtk_box_pack_start(GTK_BOX(frame_hbox), user_scan_checkbox, TRUE, TRUE, 0);
    gtk_widget_show(user_scan_checkbox);
    
    groups_userscan_checkbox = gtk_check_button_new_with_label(_("Groups scan as user"));
    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(groups_userscan_checkbox), pref.v.groups_scan_user);
    gtk_widget_set_sensitive(groups_userscan_checkbox, pref.v.shares_scan_user);
    gtk_box_pack_start(GTK_BOX(frame_hbox), groups_userscan_checkbox, TRUE, TRUE, 0);
    gtk_widget_show(groups_userscan_checkbox);

    frame_hbox = gtk_hbox_new(TRUE, 0);
    gtk_box_pack_start(GTK_BOX(frame_vbox), frame_hbox, FALSE, TRUE, 0);
    gtk_widget_show(frame_hbox);
    
    group_userscan_checkbox = gtk_check_button_new_with_label(_("Group scan as user"));
    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(group_userscan_checkbox), pref.v.machines_scan_user);
    gtk_widget_set_sensitive(group_userscan_checkbox, pref.v.shares_scan_user);
    gtk_box_pack_start(GTK_BOX(frame_hbox), group_userscan_checkbox, TRUE, TRUE, 0);
    gtk_widget_show(group_userscan_checkbox);
    
    password_once_checkbox = gtk_check_button_new_with_label(_("ask user / password once"));
    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(password_once_checkbox), pref.v.password_once);
    gtk_widget_set_sensitive(password_once_checkbox, pref.v.shares_scan_user);
    gtk_box_pack_start(GTK_BOX(frame_hbox), password_once_checkbox, TRUE, TRUE, 0);
    gtk_widget_show(password_once_checkbox);
    
    separator = gtk_hseparator_new();
    gtk_box_pack_start(GTK_BOX(frame_vbox), separator, FALSE, TRUE, 0);
    gtk_widget_show(separator);
    
    frame_hbox = gtk_hbox_new(TRUE, 0);
    gtk_box_pack_start(GTK_BOX(frame_vbox), frame_hbox, FALSE, TRUE, 0);
    gtk_widget_show(frame_hbox);
    
    group_browse_checkbox = gtk_check_button_new_with_label(_("Use group name on browse"));
    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(group_browse_checkbox), pref.v.use_group_browse);
    gtk_box_pack_start(GTK_BOX(frame_hbox), group_browse_checkbox, TRUE, TRUE, 0);
    gtk_widget_show(group_browse_checkbox);
    
    use_group_checkbox = gtk_check_button_new_with_label(_("Use group name on mount"));
    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(use_group_checkbox), pref.v.use_group_mount);
    gtk_box_pack_start(GTK_BOX(frame_hbox), use_group_checkbox, TRUE, TRUE, 0);
    gtk_widget_show(use_group_checkbox);
    
    frame_hbox = gtk_hbox_new(TRUE, 0);
    gtk_box_pack_start(GTK_BOX(frame_vbox), frame_hbox, FALSE, TRUE, 0);
    gtk_widget_show(frame_hbox);
    
    startup_browse_checkbox = gtk_check_button_new_with_label(_("Initial browse on startup"));
    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(startup_browse_checkbox), pref.v.startup_browse);
    gtk_box_pack_start(GTK_BOX(frame_hbox), startup_browse_checkbox, TRUE, TRUE, 0);
    gtk_widget_show(startup_browse_checkbox);
    
    quick_browse_checkbox = gtk_check_button_new_with_label(_("Quick Browse"));
    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(quick_browse_checkbox), pref.v.quick_browse);
    gtk_box_pack_start(GTK_BOX(frame_hbox), quick_browse_checkbox, TRUE, TRUE, 0);
    gtk_widget_show(quick_browse_checkbox);
    
    separator = gtk_hseparator_new();
    gtk_box_pack_start(GTK_BOX(frame_vbox), separator, FALSE, TRUE, 0);
    gtk_widget_show(separator);
    
    frame_hbox = gtk_hbox_new(TRUE, 0);
    gtk_box_pack_start(GTK_BOX(frame_vbox), frame_hbox, FALSE, TRUE, 3);
    gtk_widget_show(frame_hbox);
    
    use_smb_port_checkbox = gtk_check_button_new_with_label(_("Use samba port :"));
    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(use_smb_port_checkbox), pref.v.use_smb_port);
    gtk_signal_connect(GTK_OBJECT(use_smb_port_checkbox), "toggled",
                  	GTK_SIGNAL_FUNC(use_smb_port_toggled), NULL);
    gtk_box_pack_start(GTK_BOX(frame_hbox), use_smb_port_checkbox, TRUE, TRUE, 0);
    gtk_widget_show(use_smb_port_checkbox);
    
    smb_port_entry = gtk_entry_new_with_max_length(5);
    sprintf(ctemp, "%d", pref.v.smb_port);
    gtk_entry_set_text(GTK_ENTRY(smb_port_entry), ctemp);
    gtk_widget_set_sensitive(smb_port_entry, pref.v.use_smb_port);
    gtk_box_pack_start(GTK_BOX(frame_hbox), smb_port_entry, TRUE, TRUE, 0);
    gtk_widget_show(smb_port_entry);

    /* --------------------------------------------------------------------- */
    
    tablabel = gtk_label_new(_(" Programs "));
    frame = gtk_frame_new(_(" Program Execution "));
    gtk_container_border_width(GTK_CONTAINER(frame), 3);
    gtk_notebook_append_page(GTK_NOTEBOOK(notebook), frame, tablabel);
    gtk_widget_show(frame);

    frame_vbox = gtk_vbox_new(FALSE, 0);
    gtk_container_border_width(GTK_CONTAINER(frame_vbox), 5);
    gtk_container_add(GTK_CONTAINER(frame), frame_vbox);
    gtk_widget_show(frame_vbox);
    
    table = gtk_table_new(4, 3, FALSE);
    gtk_table_set_row_spacings( GTK_TABLE(table), 3);
    gtk_table_set_col_spacings( GTK_TABLE(table), 7);
    
    label = gtk_label_new("smbclient :");
    gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5);
    gtk_table_attach( GTK_TABLE(table), label, 0, 1, 0, 1,
                    	GTK_FILL, GTK_FILL | GTK_EXPAND, 0, 0);
    gtk_widget_show(label);
    
    smbclient_entry = gtk_entry_new_with_max_length(PATH_LEN-1);
    gtk_entry_set_text(GTK_ENTRY(smbclient_entry), pref.v.smbclient_exe);
   	gtk_table_attach_defaults( GTK_TABLE(table), smbclient_entry, 1, 2, 0, 1);
    gtk_widget_show(smbclient_entry);
    
    button = gtk_button_new_with_label(_("arguments"));
    gtk_signal_connect(GTK_OBJECT(button), "clicked",
                  	GTK_SIGNAL_FUNC(preferences_cmd_argument_callback), (gpointer*)1);
    gtk_table_attach_defaults( GTK_TABLE(table), button, 2, 3, 0, 1);
    gtk_widget_show(button);
    
    label = gtk_label_new("nmblookup :");
    gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5);
    gtk_table_attach( GTK_TABLE(table), label, 0, 1, 1, 2,
                    	GTK_FILL, GTK_FILL | GTK_EXPAND, 0, 0);
    gtk_widget_show(label);
    
    nmblookup_entry = gtk_entry_new_with_max_length(PATH_LEN-1);
    gtk_entry_set_text(GTK_ENTRY(nmblookup_entry), pref.v.nmblookup_exe);
    gtk_table_attach_defaults( GTK_TABLE(table), nmblookup_entry, 1, 2, 1, 2);
    gtk_widget_show(nmblookup_entry);
    
    button = gtk_button_new_with_label(_("arguments"));
    gtk_signal_connect(GTK_OBJECT(button), "clicked",
                  	GTK_SIGNAL_FUNC(preferences_cmd_argument_callback), (gpointer*)2);
    gtk_table_attach_defaults( GTK_TABLE(table), button, 2, 3, 1, 2);
    gtk_widget_show(button);

    label = gtk_label_new("smbmount :");
    gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5);
    gtk_table_attach( GTK_TABLE(table), label, 0, 1, 2, 3,
                    	GTK_FILL, GTK_FILL | GTK_EXPAND, 0, 0);
    gtk_widget_show(label);
    
    smbmount_entry = gtk_entry_new_with_max_length(PATH_LEN-1);
    gtk_entry_set_text(GTK_ENTRY(smbmount_entry), pref.v.smbmount_exe);
#ifdef NO_SMBMOUNT
    gtk_widget_set_sensitive(smbmount_entry, 0);
#endif
   	gtk_table_attach_defaults( GTK_TABLE(table), smbmount_entry, 1, 2, 2, 3);
    gtk_widget_show(smbmount_entry);
    
    button = gtk_button_new_with_label(_("arguments"));
    gtk_signal_connect(GTK_OBJECT(button), "clicked",
                  	GTK_SIGNAL_FUNC(preferences_cmd_argument_callback), (gpointer*)3);
    gtk_table_attach_defaults( GTK_TABLE(table), button, 2, 3, 2, 3);
    gtk_widget_show(button);
    
    label = gtk_label_new("smbumount :");
    gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5);
    gtk_table_attach( GTK_TABLE(table), label, 0, 1, 3, 4,
                    	GTK_FILL, GTK_FILL | GTK_EXPAND, 0, 0);
    gtk_widget_show(label);
    
    smbumount_entry = gtk_entry_new_with_max_length(PATH_LEN-1);
    gtk_entry_set_text(GTK_ENTRY(smbumount_entry), pref.v.smbumount_exe);
#ifdef NO_SMBMOUNT
    gtk_widget_set_sensitive(smbumount_entry, 0);
#endif
    gtk_table_attach_defaults( GTK_TABLE(table), smbumount_entry, 1, 2, 3, 4);
    gtk_widget_show(smbumount_entry);

    gtk_box_pack_start(GTK_BOX(frame_vbox), table, FALSE, TRUE, 0);
    gtk_widget_show(table);
    
    button = gtk_button_new_with_label(_("arguments"));
    gtk_signal_connect(GTK_OBJECT(button), "clicked",
                  	GTK_SIGNAL_FUNC(preferences_cmd_argument_callback), (gpointer*)4);
    gtk_table_attach_defaults( GTK_TABLE(table), button, 2, 3, 3, 4);
    gtk_widget_show(button);
    
    frame = gtk_frame_new(_(" smbmount version "));
    gtk_container_border_width(GTK_CONTAINER(frame), 3);
    gtk_box_pack_start(GTK_BOX(frame_vbox), frame, FALSE, TRUE, 0);
    gtk_widget_show(frame);
    
    frame_vbox = gtk_vbox_new(FALSE, 0);
    gtk_container_border_width(GTK_CONTAINER(frame_vbox), 5);
    gtk_container_add(GTK_CONTAINER(frame), frame_vbox);
    gtk_widget_show(frame_vbox);

    smbmount_204_radio = gtk_radio_button_new_with_label(NULL, _("version <= 2.0.4"));
    if ( globals.linux_version < LINUX_2_2 )
      gtk_widget_set_sensitive(smbmount_204_radio, FALSE);
    gtk_box_pack_start(GTK_BOX(frame_vbox), smbmount_204_radio, FALSE, TRUE, 0);
    gtk_widget_show(smbmount_204_radio);

    smbmount_205_radio = gtk_radio_button_new_with_label(
        gtk_radio_button_group(GTK_RADIO_BUTTON(smbmount_204_radio)), _("version = 2.0.5"));
    if ( globals.linux_version < LINUX_2_2 )
      gtk_widget_set_sensitive(smbmount_205_radio, FALSE);
    gtk_box_pack_start(GTK_BOX(frame_vbox), smbmount_205_radio, FALSE, TRUE, 0);
    gtk_widget_show(smbmount_205_radio);

    smbmount_206_radio = gtk_radio_button_new_with_label(
        gtk_radio_button_group(GTK_RADIO_BUTTON(smbmount_205_radio)), _("version >= 2.0.6"));
    if ( globals.linux_version < LINUX_2_2 )
      gtk_widget_set_sensitive(smbmount_206_radio, FALSE);
    gtk_box_pack_start(GTK_BOX(frame_vbox), smbmount_206_radio, FALSE, TRUE, 0);
    gtk_widget_show(smbmount_206_radio);
    
    switch ( pref.v.smbmount_version )
    {
      case SMBMOUNT_205:
          gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(smbmount_205_radio), 1);
          break;
      case SMBMOUNT_206:
          gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(smbmount_206_radio), 1);
          break;
      default:
          break;
    }

    /* --------------------------------------------------------------------- */
    
    tablabel = gtk_label_new(_(" Miscellaneous "));
    frame = gtk_frame_new(_(" Miscellaneous "));
    gtk_container_border_width(GTK_CONTAINER(frame), 3);
    gtk_notebook_append_page(GTK_NOTEBOOK(notebook), frame, tablabel);
    gtk_widget_show(frame);
    
    frame_vbox = gtk_vbox_new(FALSE, 0);
    gtk_container_border_width(GTK_CONTAINER(frame_vbox), 5);
    gtk_container_add(GTK_CONTAINER(frame), frame_vbox);
    gtk_widget_show(frame_vbox);
    
    table = gtk_table_new(2, 2, TRUE);

    label = gtk_label_new(_("Default User :"));
    gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
    gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
    gtk_widget_show(label);
    
    default_user_entry = gtk_entry_new_with_max_length(USER_LEN);
    gtk_entry_set_text(GTK_ENTRY(default_user_entry), pref.v.default_user);
    gtk_table_attach_defaults(GTK_TABLE(table), default_user_entry, 1, 2, 0, 1);
    gtk_widget_show(default_user_entry);
    
    default_password_checkbox = gtk_check_button_new_with_label(_("Save Default Password"));
    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(default_password_checkbox), pref.v.save_default_password);
    gtk_signal_connect(GTK_OBJECT(default_password_checkbox), "toggled",
                  	GTK_SIGNAL_FUNC(default_password_toggled), NULL);
    gtk_table_attach_defaults(GTK_TABLE(table), default_password_checkbox, 0, 1, 1, 2);
    gtk_widget_show(default_password_checkbox);
    
    default_password_entry = gtk_entry_new_with_max_length(PASSWORD_LEN);
    gtk_entry_set_visibility(GTK_ENTRY(default_password_entry), 0);	
    gtk_entry_set_text(GTK_ENTRY(default_password_entry), globals.default_password);
    gtk_widget_set_sensitive(default_password_entry, GTK_TOGGLE_BUTTON(default_password_checkbox)->active);
    gtk_table_attach_defaults(GTK_TABLE(table), default_password_entry, 1, 2, 1, 2);
    gtk_widget_show(default_password_entry);
    
    gtk_box_pack_start(GTK_BOX(frame_vbox), table, FALSE, TRUE, 3);
    gtk_widget_show(table);
    
    separator = gtk_hseparator_new();
    gtk_box_pack_start(GTK_BOX(frame_vbox), separator, FALSE, TRUE, 0);
    gtk_widget_show(separator);

    root_mnt_checkbox = gtk_check_button_new_with_label(
                         _("Use 'RootMountDir/machine/share' as default mount point"));
    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(root_mnt_checkbox), pref.v.root_mnt_enable);
    gtk_signal_connect(GTK_OBJECT(root_mnt_checkbox), "toggled",
                  	GTK_SIGNAL_FUNC(root_mnt_toggled), NULL);
    gtk_box_pack_start(GTK_BOX(frame_vbox), root_mnt_checkbox, FALSE, TRUE, 0);
    gtk_widget_show(root_mnt_checkbox);
    
    frame_hbox = gtk_hbox_new(FALSE, 0);
    gtk_box_pack_start(GTK_BOX(frame_vbox), frame_hbox, FALSE, TRUE, 3);
    gtk_widget_show(frame_hbox);
    
    label = gtk_label_new(_("Root mount dir :"));
    gtk_widget_set_usize(label, MISC_TAB_WIDTH_1, -1);
    gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
    gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
    gtk_box_pack_start(GTK_BOX(frame_hbox), label, TRUE, TRUE, 0);
    gtk_widget_show(label);
    
    root_mnt_entry = gtk_entry_new_with_max_length(PATH_LEN-1);
    gtk_entry_set_text(GTK_ENTRY(root_mnt_entry), pref.v.root_mnt_dir);
    gtk_widget_set_sensitive(root_mnt_entry, pref.v.root_mnt_enable);
    gtk_box_pack_start(GTK_BOX(frame_hbox), root_mnt_entry, TRUE, TRUE, 0);
    gtk_widget_show(root_mnt_entry);

    replace_space_mount_checkbox = gtk_check_button_new_with_label(
                         _("Replace spaces with underscores in mount path"));
    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(replace_space_mount_checkbox), pref.v.replace_space_mount);
    gtk_widget_set_sensitive(replace_space_mount_checkbox, pref.v.root_mnt_enable);
    gtk_box_pack_start(GTK_BOX(frame_vbox), replace_space_mount_checkbox, FALSE, TRUE, 0);
    gtk_widget_show(replace_space_mount_checkbox);
    
    mount_default_no_dialog_checkbox = gtk_check_button_new_with_label(
                         _("Don't show mount dialog, use defaults"));
    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(mount_default_no_dialog_checkbox), pref.v.mount_default_no_dialog);
    gtk_widget_set_sensitive(mount_default_no_dialog_checkbox, pref.v.root_mnt_enable);
    gtk_box_pack_start(GTK_BOX(frame_vbox), mount_default_no_dialog_checkbox, FALSE, TRUE, 0);
    gtk_widget_show(mount_default_no_dialog_checkbox);
    
    separator = gtk_hseparator_new();
    gtk_box_pack_start(GTK_BOX(frame_vbox), separator, FALSE, TRUE, 0);
    gtk_widget_show(separator);
    
    memorize_mount_checkbox = gtk_check_button_new_with_label(_("Memorize Mounted Shares / Remount on next Startup"));
    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(memorize_mount_checkbox), pref.v.memorize_mounts);
    gtk_box_pack_start(GTK_BOX(frame_vbox), memorize_mount_checkbox, FALSE, TRUE, 0);
    gtk_widget_show(memorize_mount_checkbox);
    
    delete_mountpoints_checkbox = gtk_check_button_new_with_label(_("Delete mount points on unmount"));
    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(delete_mountpoints_checkbox), pref.v.delete_mountpoints);
    gtk_box_pack_start(GTK_BOX(frame_vbox), delete_mountpoints_checkbox, FALSE, TRUE, 0);
    gtk_widget_show(delete_mountpoints_checkbox);
    
    /* --------------------------------------------------------------------- */
    
    tablabel = gtk_label_new(_(" Post Mount "));
    frame = gtk_frame_new(_(" Post Mount Action "));
    gtk_container_border_width(GTK_CONTAINER(frame), 3);
    gtk_notebook_append_page(GTK_NOTEBOOK(notebook), frame, tablabel);
    gtk_widget_show(frame);
    
    frame_vbox = gtk_vbox_new(FALSE, 0);
    gtk_container_border_width(GTK_CONTAINER(frame_vbox), 5);
    gtk_container_add(GTK_CONTAINER(frame), frame_vbox);
    gtk_widget_show(frame_vbox);
    
    run_fm_checkbox = gtk_check_button_new_with_label(_("Run File Manager after Mounting"));
    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(run_fm_checkbox), pref.v.run_file_manager);
    gtk_signal_connect(GTK_OBJECT(run_fm_checkbox), "toggled",
                  	GTK_SIGNAL_FUNC(run_fm_toggled), NULL);
    gtk_box_pack_start(GTK_BOX(frame_vbox), run_fm_checkbox, FALSE, TRUE, 0);
    gtk_widget_show(run_fm_checkbox);

    items = NULL;
    items = g_list_append(items, " [ MIDNIGHT COMMANDER ] \"xterm -e mc $MOUNTPOINT\"");
    items = g_list_append(items, " [ KDE ] \"kfmclient exec file:$MOUNTPOINT\"");
    items = g_list_append(items, " [ GNOME ] \"gmc $MOUNTPOINT\"");
    items = g_list_append(items, " [ XIMIAN GNOME ] \"nautilus $MOUNTPOINT\"");
    items = g_list_append(items, " [ X-Files ] \"X-files $MOUNTPOINT\"");
    items = g_list_append(items, " [ X Window Finder ] \"xwf $MOUNTPOINT\"");
    items = g_list_append(items, " [ rox ] \"rox -d $MOUNTPOINT\"");
    items = g_list_append(items, " [ File Runner ] \"fr $MOUNTPOINT\"");
    items = g_list_append(items, " [ Nautilus ] \"nautilus $MOUNTPOINT\"");
    
    run_fm_combo = gtk_combo_new();
    gtk_combo_set_popdown_strings(GTK_COMBO(run_fm_combo), items);
    entry = GTK_WIDGET(GTK_COMBO(run_fm_combo)->entry);
    gtk_entry_set_editable(GTK_ENTRY(entry), FALSE);
    gtk_widget_set_usize(run_fm_combo, -1, 30);
    gtk_box_pack_start(GTK_BOX(frame_vbox), run_fm_combo, FALSE, TRUE, 0);
    gtk_widget_show(run_fm_combo);
    
    frame_hbox = gtk_hbox_new(FALSE, 0);
    gtk_container_border_width(GTK_CONTAINER(frame_hbox), 5);
    gtk_box_set_spacing(GTK_BOX(frame_hbox), 5);
    gtk_box_pack_start(GTK_BOX(frame_vbox), frame_hbox, FALSE, TRUE, 0);
    gtk_widget_show(frame_hbox);

    copy_fm_button = gtk_button_new();
    pixmap_data = gdk_pixmap_create_from_xpm_d(main_window->window,
                                &mask, NULL, (gchar **)arrow_down_button_xpm);
    pixmap_widget = gtk_pixmap_new(pixmap_data, mask);
    gtk_container_add(GTK_CONTAINER(copy_fm_button), pixmap_widget);
    gtk_widget_show(pixmap_widget);
    gtk_signal_connect(GTK_OBJECT(copy_fm_button), "clicked",
                  	GTK_SIGNAL_FUNC(copy_fm_pressed), NULL);
    gtk_box_pack_start(GTK_BOX(frame_hbox), copy_fm_button, FALSE, TRUE, 0);
    gtk_widget_set_usize(copy_fm_button, 45, -1);
    gtk_widget_show(copy_fm_button);
    
    label = gtk_label_new(_("Press Button to move from Combo Box to Edit Field"));
    gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
    gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
    gtk_box_pack_start(GTK_BOX(frame_hbox), label, FALSE, TRUE, 0);
    gtk_widget_show(label);
    
    run_fm_entry = gtk_entry_new_with_max_length(PATH_LEN-1);
    gtk_entry_set_text(GTK_ENTRY(run_fm_entry), pref.v.filemanager_exe);
    gtk_box_pack_start(GTK_BOX(frame_vbox), run_fm_entry, FALSE, TRUE, 0);
    gtk_widget_show(run_fm_entry);

    run_fm_toggled(GTK_TOGGLE_BUTTON(run_fm_checkbox));
    
    /* ----------------------------------------------------------------- */
    
    button = gtk_button_new_with_label(_("Close"));
    GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
    gtk_signal_connect(GTK_OBJECT(button), "clicked",
                  	GTK_SIGNAL_FUNC(preferences_ok_callback), GTK_OBJECT(preferences_dlg));
    gtk_box_pack_start(GTK_BOX (GTK_DIALOG (preferences_dlg)->action_area),
                    	button, TRUE, TRUE, 0);
    gtk_widget_grab_default(button);
    gtk_widget_show(button);
    
    button = gtk_button_new_with_label(_("Save"));
    GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
    gtk_signal_connect(GTK_OBJECT(button), "clicked",
                  	GTK_SIGNAL_FUNC(preferences_save_callback), GTK_OBJECT(preferences_dlg));
    gtk_box_pack_start(GTK_BOX (GTK_DIALOG (preferences_dlg)->action_area),
                    	button, TRUE, TRUE, 0);
    gtk_widget_show(button);
    
    button = gtk_button_new_with_label(_("Cancel"));
    GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
    gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
                  	GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(preferences_dlg));
    gtk_box_pack_start(GTK_BOX (GTK_DIALOG (preferences_dlg)->action_area),
                    	button, TRUE, TRUE, 0);
    gtk_widget_show(button);
  }
    
  if ( !GTK_WIDGET_VISIBLE(preferences_dlg) )
    gtk_widget_show(preferences_dlg);
  else
    gtk_widget_destroy(preferences_dlg);
}

/* ------------------------------------------------------------------------------------- */

/* ------------------------- */
/* export mountscript dialog */
/* ------------------------- */

static char export_path[PATH_LEN+1];

/* -- callback function for MessageDlg -- */
static void export_script_msgdlg_callback (unsigned int button)
{
  /* abort ? */
  if ( button &= NO_B )
    return;

  io_write_mount_script(export_path);
}

static void export_mount_script (const char *filename)
{
  string_ncopy(export_path, filename, PATH_LEN);

  if ( file_exist(export_path) ) {
  
    ShowMessageDialog(_("Warning"),
                      _("File exists, overwrite ?"),
                      YES_B | NO_B,
                      export_script_msgdlg_callback);
  }
  else {
    export_script_msgdlg_callback(0);
  }
}

static GtkWidget *filew;

static void export_mountscript_ok_callback (GtkWidget *widget)
{
  export_mount_script(gtk_file_selection_get_filename(GTK_FILE_SELECTION(filew)));
  gtk_widget_destroy(widget);
}

static void export_mountscript_cancel_callback (GtkWidget *widget)
{
  gtk_widget_destroy(widget);
}

void export_mountscript_dialog (void)
{
  filew = gtk_file_selection_new(_("Export Mount Script"));
  gtk_window_set_modal(GTK_WINDOW(filew), TRUE);
  gtk_file_selection_set_filename(GTK_FILE_SELECTION(filew), "mountscript");
  gtk_signal_connect_object(GTK_OBJECT(GTK_FILE_SELECTION(filew)->ok_button),
           "clicked", (GtkSignalFunc)export_mountscript_ok_callback, GTK_OBJECT(filew));
  gtk_signal_connect_object(GTK_OBJECT(GTK_FILE_SELECTION(filew)->cancel_button),
           "clicked", (GtkSignalFunc)export_mountscript_cancel_callback, GTK_OBJECT(filew));
  gtk_widget_show(filew);
}

/* ------------------------------------------------------------------------ */

/* ------------------------- */
/* -- group master dialog -- */
/* ------------------------- */

static GtkWidget *gm_clist;
static gint gm_focus_row;
static char *group_master_prefname;    /* previous name if edited */
static char *group_master_prefgroup;
static void group_master_data_change_callback (data_notify_struct *notify);

static char master_browser_prefname[MAXMACHNAMEL+1];    /* previous name if edited */

static void group_master_delete_all (void)
{
  gtk_clist_clear(GTK_CLIST(gm_clist));
}

static void remove_gm_msgdlg_callback (unsigned int button)
{
  char master[MAXMACHNAMEL+1];
  char group[MAXGROUPNAMEL+1];
  char *ptemp;
  group_struct *group_st;

  /* "Yes" pressed ? */
  if ( button == YES_B )
  {
    gtk_clist_get_text(GTK_CLIST(gm_clist), gm_focus_row, 0, &ptemp);
    string_ncopy(group, ptemp, MAXGROUPNAMEL);
    gtk_clist_get_text(GTK_CLIST(gm_clist), gm_focus_row, 1, &ptemp);
    string_ncopy(master, ptemp, MAXMACHNAMEL);
    data_groupmaster_delete(group, master);
    /* delete the master from the group master list */
    group_st = group_list_search_by_name(group);
    if ( group_st != NULL )
    {
      group_list_master_delete_local(&(group_st->masterlist), master);
    }
  }
}

/* -- callback functions for Dialog(s) -- */

static void add_groupmaster_callback (const char *group, const char *master)
{
  if ( !groupmaster_list_search_by_workgroup_name(group, master) )
  {
    data_groupmaster_add(group, master, type_user_add_local);
    /* add the new master to its group master list */
    group_list_append_additional_master(group);
  }
}

static void replace_groupmaster_callback (const char *group, const char *name)
{
  group_master_struct *master;
  unsigned char has_changed;
  group_struct *group_st;
  
  has_changed = 0;
  master = groupmaster_list_search_by_workgroup_name(group_master_prefgroup, group_master_prefname);
  /* has machine name changed ? */
  if ( !compare_smb_machinename(group_master_prefname, name) )
  {
    has_changed = 1;
  }
  /* has group name changed ? */
  if ( !compare_smb_groupname(group_master_prefgroup, group) )
  {
    has_changed = 1;
  }
  
  if ( has_changed == 1 )
  {
    /* yes, new name already exists ? */
    if ( (groupmaster_list_search_by_workgroup_name(group, name)) != NULL )
    {
      ShowMessageBox(_("Error"),
                     _("Machine already exists in list !"));
      return;
    }
  }
  
  /* name is ok */
  if ( master != NULL )
  {
    /* delete old group master */
    group_st = group_list_search_by_name(master->group);
    if ( group_st != NULL )
    {
      group_list_master_delete_local(&(group_st->masterlist), master->name);
    }
    /* change properties */
    string_ncopy(master->name, name, MAXMACHNAMEL);
    string_ncopy(master->group, group, MAXGROUPNAMEL);
    notify_groupmaster_change();
    /* add new group master */
    group_list_append_additional_master(group);
  }
}

/* -- callbacks for dialog buttons -- */

static void gm_add_callback(GtkWidget *widget, gpointer data)
{
  DUAL_INPUT_DIALOG_STRUCT dialog_struct;
  
  dialog_struct.title = _(" Add Group Master");
  dialog_struct.text1 = _("Workgroup");
  dialog_struct.text2 = _("Master");
  dialog_struct.input1 = "";
  dialog_struct.input2 = "";
  dialog_struct.maxlen1 = MAXGROUPNAMEL;
  dialog_struct.maxlen2 = MAXMACHNAMEL;
  dialog_struct.ok_callback = add_groupmaster_callback;
  
  dual_input_dialog(&dialog_struct);
}

static void gm_remove_callback (GtkWidget *widget, gpointer data)
{
  char *text;
  
  if ( GTK_CLIST(gm_clist)->selection )
  {
    if ( gtk_clist_get_text(GTK_CLIST(gm_clist), GTK_CLIST(gm_clist)->focus_row, 0, &text) )
    {
      gm_focus_row = GTK_CLIST(gm_clist)->focus_row;

      ShowMessageDialog(_("Warning"),
                        _("Remove Group Master Browser ?"),
                        YES_B | NO_B,
                        remove_gm_msgdlg_callback);
    }
  }
}

static void gm_edit_callback (GtkWidget *widget, gpointer data)
{
  DUAL_INPUT_DIALOG_STRUCT dialog_struct;
  
  if ( GTK_CLIST(gm_clist)->selection )
  {
    dialog_struct.title = _(" Add Group Master");
    dialog_struct.text1 = _("Workgroup");
    dialog_struct.text2 = _("Master");
    gtk_clist_get_text(GTK_CLIST(gm_clist), GTK_CLIST(gm_clist)->focus_row, 0, &group_master_prefgroup);
    gtk_clist_get_text(GTK_CLIST(gm_clist), GTK_CLIST(gm_clist)->focus_row, 1, &group_master_prefname);
    dialog_struct.input1 = group_master_prefgroup;
    dialog_struct.input2 = group_master_prefname;
    dialog_struct.maxlen1 = MAXGROUPNAMEL;
    dialog_struct.maxlen2 = MAXMACHNAMEL;
    dialog_struct.ok_callback = replace_groupmaster_callback;

    dual_input_dialog(&dialog_struct);
  }
}

static void gm_close_callback(GtkWidget *widget, GtkWidget *dlg)
{
  notify_delete_callback(group_master_data_change_callback);
  gtk_widget_destroy(dlg);
}

static gint gm_press_event (GtkWidget *widget, GdkEventButton *event,
                                  	gpointer data)
{
  return 0;
}

static gint gm_release_event (GtkWidget *widget, GdkEventButton *event,
                                    	gpointer data)
{
  return 0;
}

static void group_master_edit_insert_enumerate (group_master_struct *master, gpointer data)
{
  GtkCList *clist;
  char *row[2];
  
  clist = GTK_CLIST(data);
  if ( (master != NULL) && (clist != NULL) )
  {
    row[0] = master->group;
    row[1] = master->name;
    gtk_clist_append(clist, row);
  }
}

static void group_master_retrigger (void)
{
  group_master_delete_all();
  /* enumerate + insert all group master browsers */
  groupmaster_list_enumerate(group_master_edit_insert_enumerate, (gpointer)(gm_clist));
}

static void group_master_data_change_callback (data_notify_struct *notify)
{
  switch ( notify->dt )
  {
    case dt_groupmaster:
        group_master_retrigger();
        break;
    
    default:
        break;
  }
}

void group_master_dialog (void)
{
  GtkWidget *gm_dlg;
  GtkWidget *vbox;
  GtkWidget *toolbar;
  GtkWidget *icon_add;
  GtkWidget *icon_remove;
  GtkWidget *icon_edit;
  GtkWidget *icon_close;
  GtkWidget *clist_win;
  
  gm_dlg = gtk_window_new(GTK_WINDOW_POPUP);
  gtk_window_set_wmclass(GTK_WINDOW(gm_dlg), "group_master", "LinNeighborhood");
  gtk_window_set_modal(GTK_WINDOW(gm_dlg), TRUE);
  gtk_window_set_policy(GTK_WINDOW(gm_dlg), 0, 0, 0);
  gtk_window_set_title(GTK_WINDOW(gm_dlg), _(" Additional Group Masters"));
  gtk_signal_connect(GTK_OBJECT(gm_dlg), "destroy",
                  	GTK_SIGNAL_FUNC(gm_close_callback), gm_dlg);
  gtk_widget_set_usize(gm_dlg, 360, 220);
  gtk_widget_realize(gm_dlg);
  
  /* main vbox */
  vbox = gtk_vbox_new(FALSE, 0);
  gtk_container_add( GTK_CONTAINER(gm_dlg), vbox);
  gtk_widget_show(vbox);
  
  /* button toolbar */
  toolbar = gtk_toolbar_new();
  gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL);
  gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH);

  gtk_box_pack_start( GTK_BOX(vbox), toolbar, FALSE, TRUE, 0);
  gtk_widget_show(toolbar);

  icon_add = new_pixmap(gm_dlg, add_xpm);
  gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), _("Add"), _("Add Master Browser"), "",
                           icon_add, GTK_SIGNAL_FUNC(gm_add_callback), NULL);

  icon_remove = new_pixmap(gm_dlg, remove_xpm);
  gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), _("  Remove  "), _("Remove Master Browser"), "",
                           icon_remove, GTK_SIGNAL_FUNC(gm_remove_callback), NULL);

  icon_edit = new_pixmap(gm_dlg, edit_xpm);
  gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), _("Edit"), _("Edit Master Browser"), "",
                           icon_edit, GTK_SIGNAL_FUNC(gm_edit_callback), NULL);

  icon_close = new_pixmap(gm_dlg, close_xpm);
  gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), _("Close"), _("Close Dialog"), "",
                           icon_close, GTK_SIGNAL_FUNC(gm_close_callback), GTK_OBJECT(gm_dlg));

  set_toolbar_tooltip_color(GTK_TOOLBAR(toolbar));
  
  /* scrolled win with CList within */
  clist_win = gtk_scrolled_window_new(NULL, NULL);
  gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(clist_win),
                                 GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
  gtk_box_pack_start( GTK_BOX(vbox), clist_win, TRUE, TRUE, 0);
  gtk_widget_show(clist_win);
  
  gm_clist = gtk_clist_new(2);
  gtk_clist_set_column_title(GTK_CLIST(gm_clist), 0, _(" Workgroup"));
  gtk_clist_set_column_title(GTK_CLIST(gm_clist), 1, _(" Group Master"));
  gtk_clist_column_titles_show(GTK_CLIST(gm_clist));
  gtk_clist_set_selection_mode( GTK_CLIST(gm_clist), GTK_SELECTION_SINGLE);
  gtk_clist_column_titles_passive( GTK_CLIST(gm_clist) );
  gtk_signal_connect(GTK_OBJECT(gm_clist), "button_press_event",
                     GTK_SIGNAL_FUNC(gm_press_event), NULL);
  gtk_signal_connect(GTK_OBJECT(gm_clist), "button_release_event",
                     GTK_SIGNAL_FUNC(gm_release_event), NULL);
  gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(clist_win), gm_clist);
  gtk_clist_set_column_width(GTK_CLIST(gm_clist), 0, 150);
  gtk_widget_show(gm_clist);
  
  /* enumerate + insert all master browsers */
  groupmaster_list_enumerate(group_master_edit_insert_enumerate, (gpointer)(gm_clist));
  
  gtk_widget_set_uposition (GTK_WIDGET(gm_dlg), 120, 100);
  gtk_widget_show(gm_dlg);

  notify_add_callback(group_master_data_change_callback);
}

/* ------------------------------------------------------------------------------------- */

/* ----------------------- */
/* -- dual input dialog -- */
/* ----------------------- */

static GtkWidget *dual_input_dlg;
static GtkWidget *dual_input1_entry;
static GtkWidget *dual_input2_entry;
static GtkWidget *dual_input_ok_button;
static dual_input_ok_callback dual_input_callback = NULL;

static void dual_input_ok_cb (GtkWidget *widget, GtkWidget *dlg)
{
  const char *input1, *input2;

  if ( dual_input_callback != NULL )
  {
    input1 = gtk_entry_get_text(GTK_ENTRY(dual_input1_entry));
    input2 = gtk_entry_get_text(GTK_ENTRY(dual_input2_entry));
    
    dual_input_callback(input1, input2);
  }

  gtk_widget_destroy(dual_input_dlg);
}

/* check for <Enter> key press */
static gboolean dual_input_key_press_callback (GtkWidget *widget, GdkEventKey *event)
{
  if ( event->keyval == GDK_Return )
  {
    if ( (GTK_WINDOW(dual_input_dlg))->default_widget == dual_input_ok_button ) {
      dual_input_ok_cb(NULL, NULL);
      return TRUE;
    }
  }
  return TRUE;
}

void dual_input_dialog (DUAL_INPUT_DIALOG_STRUCT *dialog_struct)
{
  GtkWidget *table;
  GtkWidget *label;
  GtkWidget *button;
  char ctemp[MASTER_LEN+1];

  if ( dialog_struct != NULL )
  {
    dual_input_callback = dialog_struct->ok_callback;
  
    dual_input_dlg = gtk_dialog_new();
    gtk_window_set_wmclass(GTK_WINDOW(dual_input_dlg), "dual_input", "LinNeighborhood");
    gtk_window_set_modal(GTK_WINDOW(dual_input_dlg), TRUE);
    gtk_window_set_policy(GTK_WINDOW(dual_input_dlg), 0, 0, 0);
    gtk_window_set_title(GTK_WINDOW(dual_input_dlg), dialog_struct->title);
    gtk_signal_connect(GTK_OBJECT(dual_input_dlg), "destroy",
                    GTK_SIGNAL_FUNC(gtk_widget_destroyed), &dual_input_dlg);
    gtk_widget_realize(dual_input_dlg);
    gtk_container_border_width(GTK_CONTAINER(GTK_DIALOG(dual_input_dlg)->vbox), 3);
    gtk_container_border_width(GTK_CONTAINER(GTK_DIALOG(dual_input_dlg)->action_area), 3);
    
    table = gtk_table_new(2, 2, FALSE);
    gtk_container_set_border_width(GTK_CONTAINER(table), 5);
    gtk_table_set_row_spacings(GTK_TABLE(table), 5);
    gtk_table_set_col_spacings(GTK_TABLE(table), 7);
    
    string_ncopy(ctemp, dialog_struct->text1, MASTER_LEN);
    string_ncat(ctemp, " :", MASTER_LEN);
    label = gtk_label_new(ctemp);
    gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5);
    gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
    gtk_widget_show(label);
    
    string_ncopy(ctemp, dialog_struct->text2, MASTER_LEN);
    string_ncat(ctemp, " :", MASTER_LEN);
    label = gtk_label_new(ctemp);
    gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5);
    gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2);
    gtk_widget_show(label);

    dual_input1_entry = gtk_entry_new_with_max_length(dialog_struct->maxlen1);
    gtk_entry_set_text(GTK_ENTRY(dual_input1_entry), dialog_struct->input1);
    gtk_signal_connect_object(GTK_OBJECT(dual_input1_entry), "key_press_event",
                    	GTK_SIGNAL_FUNC(dual_input_key_press_callback), NULL);
    gtk_table_attach_defaults(GTK_TABLE(table), dual_input1_entry, 1, 2, 0, 1);
    gtk_widget_show(dual_input1_entry);

    dual_input2_entry = gtk_entry_new_with_max_length(dialog_struct->maxlen2);
    gtk_entry_set_text(GTK_ENTRY(dual_input2_entry), dialog_struct->input2);
    gtk_signal_connect_object(GTK_OBJECT(dual_input2_entry), "key_press_event",
                    	GTK_SIGNAL_FUNC(dual_input_key_press_callback), NULL);
    gtk_table_attach_defaults(GTK_TABLE(table), dual_input2_entry, 1, 2, 1, 2);
    gtk_widget_show(dual_input2_entry);
    
    gtk_box_pack_start(GTK_BOX (GTK_DIALOG (dual_input_dlg)->vbox),
                      	table, FALSE, TRUE, 0);
    gtk_widget_show(table);
    
    dual_input_ok_button = gtk_button_new_with_label(_("OK"));
    GTK_WIDGET_SET_FLAGS(dual_input_ok_button, GTK_CAN_DEFAULT);
    gtk_signal_connect(GTK_OBJECT(dual_input_ok_button), "clicked",
                  	GTK_SIGNAL_FUNC(dual_input_ok_cb), GTK_OBJECT(dual_input_dlg));
    gtk_box_pack_start(GTK_BOX (GTK_DIALOG (dual_input_dlg)->action_area),
                    	dual_input_ok_button, TRUE, TRUE, 0);
    gtk_widget_grab_default(dual_input_ok_button);
    gtk_widget_show(dual_input_ok_button);
    
    button = gtk_button_new_with_label(_("Cancel"));
    GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
    gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
                  	GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(dual_input_dlg));
    gtk_box_pack_start(GTK_BOX (GTK_DIALOG (dual_input_dlg)->action_area),
                    	button, TRUE, TRUE, 0);
    gtk_widget_show(button);
    
    gtk_widget_grab_focus(dual_input1_entry);

    gtk_widget_show(dual_input_dlg);
  }
}

/* --------------------------------------------------------------------- */

/* ==================================== */
/*  shows the file copy progress dialog */
/* ==================================== */

static void dialog_file_copy_progress_close (GtkWidget *widget, gpointer data)
{
  file_copy_progress_struct *copy_struct = (file_copy_progress_struct*)data;
  
  if ( copy_struct != NULL )
  {
    /* indicate abort */
    *(copy_struct->do_exit) = 1;
    /* free struct */
    g_free(copy_struct);
  }
}

static void dialog_file_copy_progress_cancel (GtkWidget *widget, gpointer data)
{
  file_copy_progress_struct *copy_struct = (file_copy_progress_struct*)data;
  
  if ( copy_struct != NULL )
  {
    gtk_widget_destroy(GTK_WIDGET(copy_struct->dialog));
  }
}

void dialog_file_copy_progress_update (file_copy_progress_struct *copy_struct, gfloat value)
{
  if ( copy_struct != NULL )
  {
    gtk_progress_set_percentage(GTK_PROGRESS(copy_struct->progress), value);
  }
}

/*
 *  parameter: *cancel -> pointer to 'unsigned char', indicates a cancel action
 */

file_copy_progress_struct *dialog_file_copy_progress_create (unsigned char *do_cancel)
{
  file_copy_progress_struct *copy_struct;
  GtkWidget *label;
  GtkWidget *button;
  
  copy_struct = (file_copy_progress_struct*)g_malloc( sizeof(file_copy_progress_struct) );
  
  copy_struct->dialog = gtk_dialog_new();
  
  /* action on dialog closing */
  gtk_signal_connect(GTK_OBJECT(copy_struct->dialog), "destroy",
            GTK_SIGNAL_FUNC(dialog_file_copy_progress_close), copy_struct);
  
  /* set caption */
  gtk_window_set_title(GTK_WINDOW(copy_struct->dialog), _("Copy"));
  
  /* copy label */
  label = gtk_label_new(_("Copy File..."));
  gtk_misc_set_padding(GTK_MISC(label), 5, 5);
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(copy_struct->dialog)->vbox), label, TRUE, TRUE, 0);
  gtk_widget_show(label);
  
  /* progress bar */
  copy_struct->progress = gtk_progress_bar_new();
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(copy_struct->dialog)->vbox), copy_struct->progress, TRUE, TRUE, 0);
  gtk_widget_show(copy_struct->progress);
  
  /* cancel button */
  button = gtk_button_new_with_label(_("Cancel"));
  gtk_signal_connect(GTK_OBJECT(button), "clicked",
                GTK_SIGNAL_FUNC(dialog_file_copy_progress_cancel), copy_struct);
  GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  gtk_widget_grab_default(button);
  gtk_widget_show(button);
  
  gtk_widget_show(copy_struct->dialog);
  
  return copy_struct;
}

/* --------------------------------------------------------------------- */

void dialog_pointer_struct_delete (dialog_pointer_struct *d_struct)
{
  if ( d_struct != NULL )
  {
    if ( d_struct->data != NULL )
      g_free(d_struct->data);
    
    g_free(d_struct);
  }
}

/* dialog's "destroy" event */
static void dialog_close (GtkWidget *widget, gpointer data)
{
  dialog_pointer_struct *d_struct;
  
  d_struct = (dialog_pointer_struct*)data;
  
  if ( d_struct != NULL )
  {
    dialog_pointer_struct_delete(d_struct);
  }
}

/*
 *  shows a dialog, containing an 'Ok' and a 'Cancel' button
 *
 */

static void dialog_ok_cancel_callback_cancel (GtkWidget *widget, gpointer data)
{
  dialog_pointer_struct *d_struct;
  
  d_struct = (dialog_pointer_struct*)data;
  
  if ( d_struct != NULL )
  {
    gtk_widget_destroy( GTK_WIDGET(d_struct->dialog) );
  }
}

void dialog_ok_cancel (char *title, char *text, GtkSignalFunc ok_function, GtkSignalFunc cancel_function, gpointer data, int data_length)
{
  dialog_pointer_struct *d_struct;
  GtkWidget *dialog;
  GtkWidget *label;
  GtkWidget *button;
  gpointer local_data = NULL;
  
  d_struct = (dialog_pointer_struct*)g_malloc( sizeof(dialog_pointer_struct) );
  
  /* copy the data */
  if ( data != NULL )
  {
    local_data = g_malloc(data_length);
    memcpy(local_data, data, data_length);
  }
  
  dialog = gtk_dialog_new();
  
  d_struct->dialog = dialog;
  d_struct->data = local_data;
  
  gtk_signal_connect(GTK_OBJECT(dialog), "destroy", GTK_SIGNAL_FUNC(dialog_close), d_struct);
  
  gtk_window_set_title(GTK_WINDOW(dialog), title);
  gtk_container_border_width(GTK_CONTAINER(dialog), 5);
  
  label = gtk_label_new(text);
  gtk_misc_set_padding(GTK_MISC(label), 10, 10);
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), label, TRUE, TRUE, 0);
  gtk_widget_show(label);
  
  button = gtk_button_new_with_label(_("Ok"));
  gtk_signal_connect(GTK_OBJECT(button), "clicked", ok_function, d_struct);
  GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area), button, TRUE, TRUE, 0);
  gtk_widget_grab_default(button);
  gtk_widget_show(button);
  
  button = gtk_button_new_with_label(_("Cancel"));
  if ( cancel_function != NULL )
    gtk_signal_connect(GTK_OBJECT(button), "clicked", cancel_function, d_struct);
  else
    gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(dialog_ok_cancel_callback_cancel), d_struct);
  GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area), button, TRUE, TRUE, 0);
  gtk_widget_show(button);
  
  gtk_widget_show(dialog);
  
  gtk_grab_add(dialog);
}

/*
 *  shows a dialog
 *  question: 'Overwrite File'
 *
 */

void dialog_file_overwrite (GtkSignalFunc ok_function, GtkSignalFunc cancel_function, gpointer data, int data_length)
{
  dialog_ok_cancel(_("File"), _("File exists, overwrite ?"), ok_function, cancel_function, data, data_length);
}

/* ------------------------------------------------------------------------------------- */