/* 
*
*  ProLinga-Run
*
*  Copyright (C) 2002-2009 Xobas Software.
*  All rights reserved.
*  
*  This file is part of ProLinga-Run.
*
*  ProLinga-Run 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 3 of the License, or
*  (at your option) any later version.
*
*  ProLinga-Run 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 ProLinga-Run.  If not, see <http://www.gnu.org/licenses/>.
*
*  More information is available at the following addresses:
*
*  Website     : http://www.prolinga.org
*
*  Email       : prolinga-list@prolinga.org
*                QLD 9726 AUSTRALIA
*
*/

#include "RunCommon.h"
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <libxml/xpath.h>

//#include <gdk/gdkkeysyms.h>
#include <gtk/gtk.h>

#include "RunShare.hpp"
#include "RepositoryCommand.hpp"
#include "LogicCommands.hpp"
#include "Logon.hpp"
#include "BuiltIn.hpp"
#include "RunConfig.hpp"

extern GtkWidget *activeScreen;
extern ConfigRunPtr confRunPtr;
#ifndef BUILD_REPOSITORY
extern char *repositoryEndPoint;
extern int repositoryCompressionLevel;
#endif
#ifndef BUILD_VALIDATE
extern char *validateEndPoint;
extern int validateCompressionLevel;
#endif
#ifndef BUILD_DATA
extern char *dataEndPoint;
extern int dataCompressionLevel;
#endif
extern BiAppnPtr biAppnPtr;
extern BiUserPtr biUserPtr;

#define GLADE_HOOKUP_OBJECT(component,widget,name) \
  g_object_set_data_full (G_OBJECT (component), name, \
    gtk_widget_ref (widget), (GDestroyNotify) gtk_widget_unref)

#define GLADE_HOOKUP_OBJECT_NO_REF(component,widget,name) \
  g_object_set_data (G_OBJECT (component), name, widget)


GtkWidget *lookup_widget(GtkWidget *widget, const gchar *widget_name)
{
	GtkWidget *parent, *found_widget;

	for (;;)
	{
		if (GTK_IS_MENU (widget))
			parent = gtk_menu_get_attach_widget (GTK_MENU (widget));
		else
			parent = widget->parent;
		if (!parent)
			parent = (GtkWidget*) g_object_get_data (G_OBJECT (widget), "GladeParentKey");
		if (parent == NULL)
			break;
		widget = parent;
	}
	found_widget = (GtkWidget*) g_object_get_data (G_OBJECT (widget), widget_name);

	if (!found_widget)
		g_warning ("Widget not found: %s", widget_name);
	return found_widget;
}

#ifndef BUILD_REPOSITORY
void setRepositoryEndPoint(void)
{
	char tmpRepositoryEndPoint[255], *repositoryHost;
	int repositoryPort, length;

	/* Get service end point */
	repositoryHost = confRunPtr->getStringValue("RepositoryHost", DEF_REPOSITORY_HOST);
	repositoryPort = confRunPtr->getNumberValue("RepositoryPort", DEF_REPOSITORY_PORT);

	sprintf(tmpRepositoryEndPoint, "%s:%d", repositoryHost, repositoryPort);
	length = strlen(tmpRepositoryEndPoint) + 1;
	repositoryEndPoint = new char[length];

	strcpy(repositoryEndPoint, tmpRepositoryEndPoint);

        /* Get repository compression level */
        repositoryCompressionLevel = confRunPtr->getNumberValue("RepositoryCompressionLevel", DEF_REPOSITORY_COMP_LEVEL);
}
#endif

#ifndef BUILD_VALIDATE
void setValidateEndPoint(void)
{
	char tmpValidateEndPoint[255], *validateHost;
	int validatePort, length;

	/* Get service end point */
	validateHost = confRunPtr->getStringValue("ValidateHost", DEF_VALIDATE_HOST);
	validatePort = confRunPtr->getNumberValue("ValidatePort", DEF_VALIDATE_PORT);

	sprintf(tmpValidateEndPoint, "%s:%d", validateHost, validatePort);
	length = strlen(tmpValidateEndPoint) + 1;
	validateEndPoint = new char[length];

	strcpy(validateEndPoint, tmpValidateEndPoint);

        /* Get validate compression level */
        validateCompressionLevel = confRunPtr->getNumberValue("ValidateCompressionLevel", DEF_VALIDATE_COMP_LEVEL);
}
#endif

#ifndef BUILD_DATA
void setDataEndPoint(void)
{
	char tmpDataEndPoint[255], *dataHost;
	int dataPort, length;

	/* Get service end point */
	dataHost = confRunPtr->getStringValue("DataHost", DEF_DATA_HOST);
	dataPort = confRunPtr->getNumberValue("DataPort", DEF_DATA_PORT);

	sprintf(tmpDataEndPoint, "%s:%d", dataHost, dataPort);
	length = strlen(tmpDataEndPoint) + 1;
	dataEndPoint = new char[length];

	strcpy(dataEndPoint, tmpDataEndPoint);

        /* Get data compression level */
        dataCompressionLevel = confRunPtr->getNumberValue("DataCompressionLevel", DEF_DATA_COMP_LEVEL);
}
#endif

#ifndef BUILD_REPOSITORY
void freeRepositoryEndPoint(void)
{
	delete repositoryEndPoint;
}
#endif

#ifndef BUILD_VALIDATE
void freeValidateEndPoint(void)
{
	delete validateEndPoint;
}
#endif

#ifndef BUILD_DATA
void freeDataEndPoint(void)
{
	delete dataEndPoint;
}
#endif

int RepositoryLogon(void)
{
	xmlDocPtr docRes = NULL;
	xmlXPathContextPtr ctxRes = NULL;
	xmlXPathObjectPtr resRes = NULL;
	char errorMessage[255];
        GtkWidget *errorDialog;

	/* Set service end point */
#ifndef BUILD_REPOSITORY
	setRepositoryEndPoint();	
#endif
#ifndef BUILD_VALIDATE
	setValidateEndPoint();
#endif
#ifndef BUILD_DATA
	setDataEndPoint();	
#endif

	/* Check if Service is available */
	docRes = RC_Ping("Administrator", "Screen", "Runner");
	if (docRes == NULL)
		return 1;

	/* Init XPath */
	xmlXPathInit();

	/* Create XPath Environment */
	ctxRes = xmlXPathNewContext(docRes);

	/* Find out Status */
	resRes = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/@Status", ctxRes);

	/* Check Error Status */
	if (strcmp( (char *)xmlXPathCastToString(resRes), "Ok") != 0)
	{
		/* Get description */
		resRes = xmlXPathEval((const xmlChar *)"/ProLinga/Soap/Command/Error/@Id", ctxRes);
		sprintf(errorMessage, "Error: %s : ", (char *)xmlXPathCastToString(resRes));

		resRes = xmlXPathEval((const xmlChar *)"/ProLinga/Soap/Command/Error/Description", ctxRes);
		strcat(errorMessage, (char *)xmlXPathCastToString(resRes));
		strcat(errorMessage, ".\nReason: ");

		resRes = xmlXPathEval((const xmlChar *)"/ProLinga/Soap/Command/Error/External", ctxRes);
		strcat(errorMessage, (char *)xmlXPathCastToString(resRes));
		strcat(errorMessage, ".");

		/* Display Error Message */
		errorDialog = gtk_message_dialog_new (NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, errorMessage);
		gtk_dialog_run(GTK_DIALOG(errorDialog));
		gtk_widget_destroy(errorDialog);

		/* Clean up */
#ifndef BUILD_REPOSITORY
		freeRepositoryEndPoint();
#endif
#ifndef BUILD_VALIDATE
		freeValidateEndPoint();	
#endif
#ifndef BUILD_DATA
		freeDataEndPoint();	
#endif
		xmlFreeDoc(docRes);

		/* Return to logon screen */
		return 1;
	}

	/* Free Document */
	xmlFreeDoc(docRes);

	/* Return */
	return 0;
}

void AdmLogon()
{
	const char *argList[255];
	char logon_appn[32], logon_user[32];
	bool isMainThread = true;

	RepositoryLogon();

	/* Get logon appn and user */
	strcpy(logon_appn, biAppnPtr->getAppn());
	strcpy(logon_user, biUserPtr->getUser());

	if ((strlen(logon_appn) > 0) || (strlen(logon_user) > 0))
	{
		/* Call Redirect Logic */
		argList[1] = "Redirect";
		argList[2] = logon_appn;
		argList[3] = logon_user;
		biAppnPtr->setAppn("Administrator");
		CmdCall(argList, 3, isMainThread, false);
	}
	else
	{
		/* Call Main screen administrator */
		biAppnPtr->setAppn("Administrator");
		argList[1] = "Runner";
		CmdCall(argList, 1, isMainThread, false);
	}
}
	
#if !defined(BUILD_REPOSITORY) || !defined(BUILD_VALIDATE) || !defined(BUILD_DATA)
extern "C" void on_logon_button_ok_clicked (GtkObject *object, gpointer user_data)
{
	const char *argList[255];
	GtkWidget *logon;
	bool isMainThread = true;
	char logon_appn[32], logon_user[32];

	if (RepositoryLogon() == 0)
	{
		/* Get logon appn and user */
		strcpy(logon_appn, biAppnPtr->getAppn());
		strcpy(logon_user, biUserPtr->getUser());

		/* Close logon screen */
		logon = lookup_widget(GTK_WIDGET(object), "Logon");
		gtk_widget_destroy(logon);

		if ((strlen(logon_appn) > 0) || (strlen(logon_user) > 0))
		{
			/* Call Redirect Logic */
			argList[1] = "Redirect";
			argList[2] = logon_appn;
			argList[3] = logon_user;
			biAppnPtr->setAppn("Administrator");
			CmdCall(argList, 3, isMainThread, false);
		}
		else
		{
			/* Call Main screen administrator */
			biAppnPtr->setAppn("Administrator");
			argList[1] = "Runner";
			CmdCall(argList, 1, isMainThread, false);
		}

	}
}

void on_logon_button_cancel_clicked (GtkObject *object, gpointer user_data)
{
	gtk_main_quit();
}

#if !defined(BUILD_REPOSITORY)
extern "C" gboolean on_entry_rep_server_clicked (GtkObject *object, gpointer user_data)
{
	const gchar *retValue;

	/* Get updated value */	
	retValue = gtk_entry_get_text(GTK_ENTRY(object));

	/* Store in config mem */
	confRunPtr->putStringValue("RepositoryHost", (char *)retValue);

	/* Exit */
	return FALSE;
}

extern "C" gboolean on_entry_rep_port_clicked (GtkObject *object, gpointer user_data)
{
	const gchar *retValue;

	/* Get updated value */	
	retValue = gtk_entry_get_text(GTK_ENTRY(object));

	/* Store in config mem */
	confRunPtr->putNumberValue("RepositoryPort", atoi((char *)retValue));

	/* Exit */
	return FALSE;
}
#endif

#if !defined(BUILD_DATA)
extern "C" gboolean on_entry_dat_server_clicked (GtkObject *object, gpointer user_data)
{
	const gchar *retValue;

	/* Get updated value */	
	retValue = gtk_entry_get_text(GTK_ENTRY(object));

	/* Store in config mem */
	confRunPtr->putStringValue("DataHost", (char *)retValue);

	/* Exit */
	return FALSE;
}

extern "C" gboolean on_entry_dat_port_clicked (GtkObject *object, gpointer user_data)
{
	const gchar *retValue;

	/* Get updated value */	
	retValue = gtk_entry_get_text(GTK_ENTRY(object));

	/* Store in config mem */
	confRunPtr->putNumberValue("DataPort", atoi((char *)retValue));

	/* Exit */
	return FALSE;
}
#endif

#if !defined(BUILD_VALIDATE)
extern "C" gboolean on_entry_val_server_clicked (GtkObject *object, gpointer user_data)
{
	const gchar *retValue;

	/* Get updated value */	
	retValue = gtk_entry_get_text(GTK_ENTRY(object));

	/* Store in config mem */
	confRunPtr->putStringValue("ValidateHost", (char *)retValue);

	/* Exit */
	return FALSE;
}

extern "C" gboolean on_entry_val_port_clicked (GtkObject *object, gpointer user_data)
{
	const gchar *retValue;

	/* Get updated value */	
	retValue = gtk_entry_get_text(GTK_ENTRY(object));

	/* Store in config mem */
	confRunPtr->putNumberValue("ValidatePort", atoi((char *)retValue));

	/* Exit */
	return FALSE;
}
#endif

GtkWidget*
create_Logon (void)
{
  GtkWidget *Logon;
  GtkWidget *vbox2;
#if !defined(BUILD_REPOSITORY)
  GtkWidget *label_rep_server;
  GtkWidget *entry_rep_server;
  GtkWidget *label_rep_port;
  GtkWidget *entry_rep_port;
#endif
#if !defined(BUILD_DATA)
  GtkWidget *label_dat_server;
  GtkWidget *entry_dat_server;
  GtkWidget *label_dat_port;
  GtkWidget *entry_dat_port;
#endif
#if !defined(BUILD_VALIDATE)
  GtkWidget *label_val_server;
  GtkWidget *entry_val_server;
  GtkWidget *label_val_port;
  GtkWidget *entry_val_port;
#endif
  char tmpString[1024];
  GtkWidget *hbuttonbox1;
  GtkWidget *logon_button_cancel;
  GtkWidget *logon_button_ok;
  GtkAccelGroup *accel_group;

  accel_group = gtk_accel_group_new ();

  Logon = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title (GTK_WINDOW (Logon), "ProLinga-Web Services End-Points");
  gtk_window_set_position(GTK_WINDOW (Logon), GTK_WIN_POS_CENTER);
  gtk_window_set_default_size(GTK_WINDOW (Logon), 400, 200);

  vbox2 = gtk_vbox_new (FALSE, 5);
  gtk_widget_show (vbox2);
  gtk_container_add (GTK_CONTAINER (Logon), vbox2);
  gtk_container_set_border_width (GTK_CONTAINER (vbox2), 20);
#if !defined(BUILD_REPOSITORY)
  label_rep_server = gtk_label_new ("Repository Host or IP :");
  gtk_widget_show (label_rep_server);
  gtk_box_pack_start (GTK_BOX (vbox2), label_rep_server, FALSE, FALSE, 0);
  gtk_label_set_justify (GTK_LABEL (label_rep_server), GTK_JUSTIFY_LEFT);
  gtk_misc_set_alignment (GTK_MISC (label_rep_server), 0, 0.5);

  entry_rep_server = gtk_entry_new ();
  gtk_entry_set_text(GTK_ENTRY(entry_rep_server), confRunPtr->getStringValue("RepositoryHost", DEF_REPOSITORY_HOST));

  gtk_widget_show (entry_rep_server);
  gtk_box_pack_start (GTK_BOX (vbox2), entry_rep_server, FALSE, FALSE, 0);
  gtk_entry_set_max_length (GTK_ENTRY (entry_rep_server), 255);
  gtk_entry_set_activates_default (GTK_ENTRY (entry_rep_server), TRUE);

  label_rep_port = gtk_label_new ("Repository Port Number :");
  gtk_widget_show (label_rep_port);
  gtk_box_pack_start (GTK_BOX (vbox2), label_rep_port, FALSE, FALSE, 0);
  gtk_label_set_justify (GTK_LABEL (label_rep_port), GTK_JUSTIFY_LEFT);
  gtk_misc_set_alignment (GTK_MISC (label_rep_port), 0, 0.5);

  entry_rep_port = gtk_entry_new ();
  sprintf(tmpString, "%d", confRunPtr->getNumberValue("RepositoryPort", DEF_REPOSITORY_PORT)); 
  gtk_entry_set_text(GTK_ENTRY(entry_rep_port), tmpString);

  gtk_widget_show (entry_rep_port);
  gtk_box_pack_start (GTK_BOX (vbox2), entry_rep_port, FALSE, FALSE, 0);
  gtk_entry_set_max_length (GTK_ENTRY (entry_rep_port), 5);
  gtk_entry_set_activates_default (GTK_ENTRY (entry_rep_port), TRUE);
#endif
#if !defined(BUILD_DATA)
  label_dat_server = gtk_label_new ("Data Host or IP :");
  gtk_widget_show (label_dat_server);
  gtk_box_pack_start (GTK_BOX (vbox2), label_dat_server, FALSE, FALSE, 0);
  gtk_label_set_justify (GTK_LABEL (label_dat_server), GTK_JUSTIFY_LEFT);
  gtk_misc_set_alignment (GTK_MISC (label_dat_server), 0, 0.5);

  entry_dat_server = gtk_entry_new ();
  gtk_entry_set_text(GTK_ENTRY(entry_dat_server), confRunPtr->getStringValue("DataHost", DEF_DATA_HOST));

  gtk_widget_show (entry_dat_server);
  gtk_box_pack_start (GTK_BOX (vbox2), entry_dat_server, FALSE, FALSE, 0);
  gtk_entry_set_max_length (GTK_ENTRY (entry_dat_server), 255);
  gtk_entry_set_activates_default (GTK_ENTRY (entry_dat_server), TRUE);

  label_dat_port = gtk_label_new ("Data Port Number :");
  gtk_widget_show (label_dat_port);
  gtk_box_pack_start (GTK_BOX (vbox2), label_dat_port, FALSE, FALSE, 0);
  gtk_label_set_justify (GTK_LABEL (label_dat_port), GTK_JUSTIFY_LEFT);
  gtk_misc_set_alignment (GTK_MISC (label_dat_port), 0, 0.5);

  entry_dat_port = gtk_entry_new ();
  sprintf(tmpString, "%d", confRunPtr->getNumberValue("DataPort", DEF_DATA_PORT)); 
  gtk_entry_set_text(GTK_ENTRY(entry_dat_port), tmpString);

  gtk_widget_show (entry_dat_port);
  gtk_box_pack_start (GTK_BOX (vbox2), entry_dat_port, FALSE, FALSE, 0);
  gtk_entry_set_max_length (GTK_ENTRY (entry_dat_port), 5);
  gtk_entry_set_activates_default (GTK_ENTRY (entry_dat_port), TRUE);
#endif
#if !defined(BUILD_VALIDATE)
  label_val_server = gtk_label_new ("Validate Host or IP :");
  gtk_widget_show (label_val_server);
  gtk_box_pack_start (GTK_BOX (vbox2), label_val_server, FALSE, FALSE, 0);
  gtk_label_set_justify (GTK_LABEL (label_val_server), GTK_JUSTIFY_LEFT);
  gtk_misc_set_alignment (GTK_MISC (label_val_server), 0, 0.5);

  entry_val_server = gtk_entry_new ();
  gtk_entry_set_text(GTK_ENTRY(entry_val_server), confRunPtr->getStringValue("ValidateHost", DEF_VALIDATE_HOST));

  gtk_widget_show (entry_val_server);
  gtk_box_pack_start (GTK_BOX (vbox2), entry_val_server, FALSE, FALSE, 0);
  gtk_entry_set_max_length (GTK_ENTRY (entry_val_server), 255);
  gtk_entry_set_activates_default (GTK_ENTRY (entry_val_server), TRUE);

  label_val_port = gtk_label_new ("Validate Port Number :");
  gtk_widget_show (label_val_port);
  gtk_box_pack_start (GTK_BOX (vbox2), label_val_port, FALSE, FALSE, 0);
  gtk_label_set_justify (GTK_LABEL (label_val_port), GTK_JUSTIFY_LEFT);
  gtk_misc_set_alignment (GTK_MISC (label_val_port), 0, 0.5);

  entry_val_port = gtk_entry_new ();
  sprintf(tmpString, "%d", confRunPtr->getNumberValue("ValidatePort", DEF_VALIDATE_PORT)); 
  gtk_entry_set_text(GTK_ENTRY(entry_val_port), tmpString);

  gtk_widget_show (entry_val_port);
  gtk_box_pack_start (GTK_BOX (vbox2), entry_val_port, FALSE, FALSE, 0);
  gtk_entry_set_max_length (GTK_ENTRY (entry_val_port), 5);
  gtk_entry_set_activates_default (GTK_ENTRY (entry_val_port), TRUE);
#endif

/*
  label_dataserver = gtk_label_new ("Data Server or IP :");
  gtk_widget_show (label_dataserver);
  gtk_box_pack_start (GTK_BOX (vbox2), label_dataserver, FALSE, FALSE, 0);
  gtk_label_set_justify (GTK_LABEL (label_dataserver), GTK_JUSTIFY_LEFT);
  gtk_misc_set_alignment (GTK_MISC (label_dataserver), 0, 0.5);

  entry_dataserver = gtk_entry_new ();
  gtk_widget_show (entry_dataserver);
  gtk_box_pack_start (GTK_BOX (vbox2), entry_dataserver, FALSE, FALSE, 0);
  gtk_entry_set_max_length (GTK_ENTRY (entry_dataserver), 255);
  gtk_entry_set_activates_default (GTK_ENTRY (entry_dataserver), TRUE);

  label_user = gtk_label_new ("User Name :");
  gtk_widget_show (label_user);
  gtk_box_pack_start (GTK_BOX (vbox2), label_user, FALSE, FALSE, 0);
  gtk_label_set_justify (GTK_LABEL (label_user), GTK_JUSTIFY_LEFT);
  gtk_misc_set_alignment (GTK_MISC (label_user), 0, 0.5);

  entry_user = gtk_entry_new ();
  gtk_widget_show (entry_user);
  gtk_box_pack_start (GTK_BOX (vbox2), entry_user, FALSE, FALSE, 0);
  gtk_entry_set_max_length (GTK_ENTRY (entry_user), 32);
  gtk_entry_set_activates_default (GTK_ENTRY (entry_user), TRUE);

  label_password = gtk_label_new ("Password :");
  gtk_widget_show (label_password);
  gtk_box_pack_start (GTK_BOX (vbox2), label_password, FALSE, FALSE, 0);
  gtk_label_set_justify (GTK_LABEL (label_password), GTK_JUSTIFY_LEFT);
  gtk_misc_set_alignment (GTK_MISC (label_password), 0, 0.5);

  entry_password = gtk_entry_new ();
  gtk_widget_show (entry_password);
  gtk_box_pack_start (GTK_BOX (vbox2), entry_password, FALSE, FALSE, 0);
  gtk_entry_set_visibility (GTK_ENTRY (entry_password), FALSE);
  gtk_entry_set_activates_default (GTK_ENTRY (entry_password), TRUE);
*/

  hbuttonbox1 = gtk_hbutton_box_new ();
  gtk_widget_show (hbuttonbox1);
  gtk_box_pack_end (GTK_BOX (vbox2), hbuttonbox1, FALSE, TRUE, 0);
  gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox1), GTK_BUTTONBOX_END);

  logon_button_cancel = gtk_button_new_from_stock ("gtk-cancel");
  gtk_widget_show (logon_button_cancel);
  gtk_container_add (GTK_CONTAINER (hbuttonbox1), logon_button_cancel);
  GTK_WIDGET_SET_FLAGS (logon_button_cancel, GTK_CAN_DEFAULT);
  //gtk_widget_add_accelerator (logon_button_cancel, "activate", accel_group, GDK_Escape, 0, GTK_ACCEL_VISIBLE);

  logon_button_ok = gtk_button_new_from_stock ("gtk-ok");
  gtk_widget_show (logon_button_ok);
  gtk_container_add (GTK_CONTAINER (hbuttonbox1), logon_button_ok);
  GTK_WIDGET_SET_FLAGS (logon_button_ok, GTK_CAN_DEFAULT);

#if !defined(BUILD_REPOSITORY)
  g_signal_connect ((gpointer) entry_rep_server, "focus_out_event",
                    G_CALLBACK (on_entry_rep_server_clicked),
                    NULL);
  g_signal_connect ((gpointer) entry_rep_port, "focus_out_event",
                    G_CALLBACK (on_entry_rep_port_clicked),
                    NULL);
#endif
#if !defined(BUILD_DATA)
  g_signal_connect ((gpointer) entry_dat_server, "focus_out_event",
                    G_CALLBACK (on_entry_dat_server_clicked),
                    NULL);
  g_signal_connect ((gpointer) entry_dat_port, "focus_out_event",
                    G_CALLBACK (on_entry_dat_port_clicked),
                    NULL);
#endif
#if !defined(BUILD_VALIDATE)
  g_signal_connect ((gpointer) entry_val_server, "focus_out_event",
                    G_CALLBACK (on_entry_val_server_clicked),
                    NULL);
  g_signal_connect ((gpointer) entry_val_port, "focus_out_event",
                    G_CALLBACK (on_entry_val_port_clicked),
                    NULL);
#endif
  g_signal_connect ((gpointer) logon_button_cancel, "clicked",
                    G_CALLBACK (on_logon_button_cancel_clicked),
                    NULL);
  g_signal_connect ((gpointer) logon_button_ok, "clicked",
                    G_CALLBACK (on_logon_button_ok_clicked),
                    NULL);

  /* Store pointers to all widgets, for use by lookup_widget(). */
  GLADE_HOOKUP_OBJECT_NO_REF (Logon, Logon, "Logon");
  GLADE_HOOKUP_OBJECT (Logon, vbox2, "vbox2");
#if !defined(BUILD_REPOSITORY)
  GLADE_HOOKUP_OBJECT (Logon, label_rep_server, "label_rep_server");
  GLADE_HOOKUP_OBJECT (Logon, entry_rep_server, "entry_rep_server");
  GLADE_HOOKUP_OBJECT (Logon, label_rep_port, "label_rep_port");
  GLADE_HOOKUP_OBJECT (Logon, entry_rep_port, "entry_rep_port");
#endif
#if !defined(BUILD_DATA)
  GLADE_HOOKUP_OBJECT (Logon, label_dat_server, "label_dat_server");
  GLADE_HOOKUP_OBJECT (Logon, entry_dat_server, "entry_dat_server");
  GLADE_HOOKUP_OBJECT (Logon, label_dat_port, "label_dat_port");
  GLADE_HOOKUP_OBJECT (Logon, entry_dat_port, "entry_dat_port");
#endif
#if !defined(BUILD_VALIDATE)
  GLADE_HOOKUP_OBJECT (Logon, label_val_server, "label_val_server");
  GLADE_HOOKUP_OBJECT (Logon, entry_val_server, "entry_val_server");
  GLADE_HOOKUP_OBJECT (Logon, label_val_port, "label_val_port");
  GLADE_HOOKUP_OBJECT (Logon, entry_val_port, "entry_val_port");
#endif
/*
  GLADE_HOOKUP_OBJECT (Logon, label_user, "label_user");
  GLADE_HOOKUP_OBJECT (Logon, entry_user, "entry_user");
  GLADE_HOOKUP_OBJECT (Logon, label_password, "label_password");
  GLADE_HOOKUP_OBJECT (Logon, entry_password, "entry_password");
*/
  GLADE_HOOKUP_OBJECT (Logon, hbuttonbox1, "hbuttonbox1");
  GLADE_HOOKUP_OBJECT (Logon, logon_button_cancel, "logon_button_cancel");
  GLADE_HOOKUP_OBJECT (Logon, logon_button_ok, "logon_button_ok");

#if !defined(BUILD_REPOSITORY)
  gtk_widget_grab_focus (entry_rep_server);
#elif !defined(BUILD_DATA)
  gtk_widget_grab_focus (entry_dat_server);
#elif !defined(BUILD_VALIDATE)
  gtk_widget_grab_focus (entry_val_server);
#endif
  gtk_widget_grab_default (logon_button_ok);
  gtk_window_add_accel_group (GTK_WINDOW (Logon), accel_group);

  return Logon;
}
#endif