// 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. 

// Copyright 2003 Liam Girdwood  

#include "config.h"
#include "vsky_druid.hh"
#include "todo_dialog.hh"
#include <libgnome/libgnome.h>
#include <gdk/gdkkeysyms.h>
#include <gtkmm/accelgroup.h>

namespace GUI
{

/*! \fn VSkyDruid::VSkyDruid()
*
* Virtusl sky druid constructor.
* Create all the druid pages and display druid.
*/
VSkyDruid::VSkyDruid()
{  
	// create druid
	m_druid = Gtk::manage(new Gnome::UI::Druid());
	
	m_is_location_complete = false;	
	m_is_date_complete = false;		
	m_is_zone_complete = false;
	ln_get_date_from_sys(&m_date);
	m_JD = ln_get_julian_from_sys();
	
	// create pages
	create_page_start ();
	create_page_location ();
	create_page_date ();
	create_page_zone ();
	create_page_finish ();
	
	// append pages
	m_druid->append_page(*m_vsky_druidpagestart);
	m_druid->append_page(*m_posn_druidpage);
	m_druid->append_page(*m_date_time_druidpage);
	m_druid->append_page(*m_timezone_druidpage);
	m_druid->append_page(*m_vsky_druidpagefinish);
	
	// druid settings
	set_border_width(2);
	set_title("Create a new Sky View");
	set_modal(true);
	property_window_position().set_value(Gtk::WIN_POS_NONE);
	set_resizable(false);
	set_size_request(500, 450);
	get_vbox()->pack_start(*m_druid);
	
	m_druid->set_show_help(true);
	m_druid->set_border_width(4);
	m_druid->show_all();
	
	m_long.degrees = 0;
	m_long.minutes = 0;
	m_long.seconds = 0;
	m_lat.degrees = 0;
	m_lat.minutes = 0;
	m_lat.seconds = 0;
	
	// connect druid signal handlers
	m_druid->signal_cancel().connect(SigC::slot(*this, &VSkyDruid::on_vsky_druid_cancel));
	m_druid->signal_help().connect(SigC::slot(*this, &VSkyDruid::on_vsky_druid_help));
}


/*! \fn VSkyDruid::~VSkyDruid()
*
* Virtual sky druid destructor
*/
VSkyDruid::~VSkyDruid()
{
}

/*! \fn void set_vsky(Vega::VirtualSky* sky);
*
*/
void VSkyDruid::set_vsky(Vega::VirtualSky* sky)
{
	m_vsky = sky;
	refresh_date();
	m_vsky->set_jd(m_JD);
	m_vsky->set_live(true);
}


/*! \fn void VSkyDruid::create_page_start (void)
*
* Create the virtual sky druid start page.
*/
void VSkyDruid::create_page_start (void)
{
	// create page
	m_vsky_druidpagestart = Gtk::manage(new Gnome::UI::DruidPageEdge(Gnome::UI::EDGE_START));
	
	// page settings
	m_vsky_druidpagestart->set_border_width(1);
	m_vsky_druidpagestart->set_title_color(Gdk::Color("#ffffff"));
	m_vsky_druidpagestart->set_logo_bg_color(Gdk::Color("#ffffff"));
	m_vsky_druidpagestart->set_title(  ("Creating a new Sky View"));
	m_vsky_druidpagestart->set_text_color(Gdk::Color("#000000"));
	m_vsky_druidpagestart->set_textbox_color(Gdk::Color("#ffffff"));
	m_vsky_druidpagestart->set_text(  ("This assistant will guide you through the\ncreation of a new night sky view on your computer."));
}


/*! \fn void VSkyDruid::create_page_location (void)
*
* Create the virtual sky location page.
* This may be expanded to include an optional world map
* like evolution does.
*/
void VSkyDruid::create_page_location (void)
{	
	// create location widgets
	Gtk::Tooltips _tooltips;
	Glib::RefPtr<Gtk::AccelGroup> accgrp;
	m_location_vbox = Gtk::manage(new class Gtk::VBox());
	m_location_label = Gtk::manage(new class Gtk::Label(_("<b>Observing Location</b>")));
	m_name_label = Gtk::manage(new class Gtk::Label(_("_Name"), true));
	m_name_entry = Gtk::manage(new class Gtk::Entry());
	m_name_hbox = Gtk::manage(new class Gtk::HBox(false, 6));
	m_position_label = Gtk::manage(new class Gtk::Label(_("<b>Observer Position</b>\n"
			"<i>Note: Nova measures longitude positively westwards.</i>")));
	m_lat_deg_spinbutton_adj = Gtk::manage(new class Gtk::Adjustment(0, -90, 90, 1, 10, 10));
	m_lat_deg_spinbutton = Gtk::manage(new class Gtk::SpinButton(*m_lat_deg_spinbutton_adj, 1, 0));
	m_lat_label1 = Gtk::manage(new class Gtk::Label(_(":")));
	m_lat_min_spinbutton_adj = Gtk::manage(new class Gtk::Adjustment(0, 0, 59, 1, 10, 10));
	m_lat_min_spinbutton = Gtk::manage(new class Gtk::SpinButton(*m_lat_min_spinbutton_adj, 1, 0));
	m_lat_label2 = Gtk::manage(new class Gtk::Label(_(":")));
	m_lat_sec_spinbutton_adj = Gtk::manage(new class Gtk::Adjustment(0, 0, 59.9, 1, 10, 10));
	m_lat_sec_spinbutton = Gtk::manage(new class Gtk::SpinButton(*m_lat_sec_spinbutton_adj, 1, 1));
	m_lat_hbox = Gtk::manage(new class Gtk::HBox(false, 0));
	m_long_deg_spinbutton_adj = Gtk::manage(new class Gtk::Adjustment(0, 0, 359, 1, 10, 10));
	m_long_deg_spinbutton = Gtk::manage(new class Gtk::SpinButton(*m_long_deg_spinbutton_adj, 1, 0));
	m_long_label1 = Gtk::manage(new class Gtk::Label(_(":")));
	m_long_min_spinbutton_adj = Gtk::manage(new class Gtk::Adjustment(0, 0, 59, 1, 10, 10));
	m_long_min_spinbutton = Gtk::manage(new class Gtk::SpinButton(*m_long_min_spinbutton_adj, 1, 0));
	m_long_label2 = Gtk::manage(new class Gtk::Label(_(":")));
	m_long_sec_spinbutton_adj = Gtk::manage(new class Gtk::Adjustment(0, 0, 59.9, 1, 10, 10));
	m_long_sec_spinbutton = Gtk::manage(new class Gtk::SpinButton(*m_long_sec_spinbutton_adj, 1, 1));
	m_long_hbox = Gtk::manage(new class Gtk::HBox(false, 0));
	m_elevation_spinbutton_adj = Gtk::manage(new class Gtk::Adjustment(0, -500, 10000, 1, 10, 10));
	m_elevation_spinbutton = Gtk::manage(new class Gtk::SpinButton(*m_elevation_spinbutton_adj, 1, 0));
	m_latitude_label = Gtk::manage(new class Gtk::Label(_("L_atitude (d:m:s)"), true));
	m_longitude_label = Gtk::manage(new class Gtk::Label(_("L_ongitude (d:m:s)"), true));
	m_elevation_label = Gtk::manage(new class Gtk::Label(_("_Elevation (m)"), true));
	m_position_table = Gtk::manage(new class Gtk::Table(2, 2, false));
	m_druid_location_vbox = Gtk::manage(new Gtk::VBox(false, 6));
	m_posn_druidpage = Gtk::manage(new Gnome::UI::DruidPageStandard());

	// init location widgets	
	m_location_label->set_alignment(0,0.5);
	m_location_label->set_padding(0,6);
	m_location_label->set_justify(Gtk::JUSTIFY_LEFT);
	m_location_label->set_line_wrap(false);
	m_location_label->set_use_markup(true);
	m_location_label->set_selectable(false);
	
	m_name_label->set_alignment(0.3,0.5);
	m_name_label->set_padding(0,0);
	m_name_label->set_justify(Gtk::JUSTIFY_LEFT);
	m_name_label->set_line_wrap(false);
	m_name_label->set_use_markup(true);
	m_name_label->set_selectable(false);
	m_name_label->set_mnemonic_widget(*m_name_entry);
	
	m_name_entry->set_flags(Gtk::CAN_FOCUS);
	_tooltips.set_tip(*m_name_entry, _("Name of your Observatory or observing location"), "");
	//m_name_entry->add_accelerator("grab_focus", accgrp, GDK_N, Gdk::MOD1_MASK, Gtk::ACCEL_VISIBLE);
	m_name_entry->set_visibility(true);
	m_name_entry->set_editable(true);
	m_name_entry->set_max_length(0);
	m_name_entry->set_text(_(""));
	m_name_entry->set_has_frame(true);
	m_name_entry->set_activates_default(false);
	
	m_name_hbox->set_border_width(6);
	m_name_hbox->pack_start(*m_name_label);
	m_name_hbox->pack_start(*m_name_entry);
	
	m_position_label->set_alignment(0,0.5);
	m_position_label->set_padding(0,6);
	m_position_label->set_justify(Gtk::JUSTIFY_LEFT);
	m_position_label->set_line_wrap(false);
	m_position_label->set_use_markup(true);
	m_position_label->set_selectable(false);
	
	m_lat_deg_spinbutton->set_flags(Gtk::CAN_FOCUS);
	_tooltips.set_tip(*m_lat_deg_spinbutton, _("Latitude in degrees of your location"), "");
	//m_lat_deg_spinbutton->add_accelerator("grab_focus", accgrp, GDK_a, Gdk::MOD1_MASK, Gtk::ACCEL_VISIBLE);
	m_lat_deg_spinbutton->set_update_policy(Gtk::UPDATE_ALWAYS);
	m_lat_deg_spinbutton->set_numeric(true);
	m_lat_deg_spinbutton->set_digits(0);
	m_lat_deg_spinbutton->set_wrap(true);
	
	m_lat_label1->set_alignment(0.5,0.5);
	m_lat_label1->set_padding(0,0);
	m_lat_label1->set_justify(Gtk::JUSTIFY_LEFT);
	m_lat_label1->set_line_wrap(false);
	m_lat_label1->set_use_markup(false);
	m_lat_label1->set_selectable(false);
	
	m_lat_min_spinbutton->set_flags(Gtk::CAN_FOCUS);
	_tooltips.set_tip(*m_lat_min_spinbutton, _("Latitude in minutes of your location"), "");
	m_lat_min_spinbutton->set_update_policy(Gtk::UPDATE_ALWAYS);
	m_lat_min_spinbutton->set_numeric(true);
	m_lat_min_spinbutton->set_digits(0);
	m_lat_min_spinbutton->set_wrap(true);
	
	m_lat_label2->set_alignment(0.5,0.5);
	m_lat_label2->set_padding(0,0);
	m_lat_label2->set_justify(Gtk::JUSTIFY_LEFT);
	m_lat_label2->set_line_wrap(false);
	m_lat_label2->set_use_markup(false);
	m_lat_label2->set_selectable(false);
	
	m_lat_sec_spinbutton->set_flags(Gtk::CAN_FOCUS);
	_tooltips.set_tip(*m_lat_sec_spinbutton, _("Latitude in seconds of your location"), "");
	m_lat_sec_spinbutton->set_update_policy(Gtk::UPDATE_ALWAYS);
	m_lat_sec_spinbutton->set_numeric(true);
	m_lat_sec_spinbutton->set_digits(1);
	m_lat_sec_spinbutton->set_wrap(true);
	
	m_lat_hbox->pack_start(*m_lat_deg_spinbutton);
	m_lat_hbox->pack_start(*m_lat_label1, Gtk::PACK_SHRINK, 0);
	m_lat_hbox->pack_start(*m_lat_min_spinbutton);
	m_lat_hbox->pack_start(*m_lat_label2, Gtk::PACK_SHRINK, 0);
	m_lat_hbox->pack_start(*m_lat_sec_spinbutton);
	
	m_long_deg_spinbutton->set_flags(Gtk::CAN_FOCUS);
	_tooltips.set_tip(*m_long_deg_spinbutton, _("Longitude in degrees of your location"), "");
	//m_long_deg_spinbutton->add_accelerator("grab_focus", accgrp, GDK_o, Gdk::MOD1_MASK, Gtk::ACCEL_VISIBLE);
	m_long_deg_spinbutton->set_update_policy(Gtk::UPDATE_ALWAYS);
	m_long_deg_spinbutton->set_numeric(true);
	m_long_deg_spinbutton->set_digits(0);
	m_long_deg_spinbutton->set_wrap(true);
	
	m_long_label1->set_alignment(0.5,0.5);
	m_long_label1->set_padding(0,0);
	m_long_label1->set_justify(Gtk::JUSTIFY_LEFT);
	m_long_label1->set_line_wrap(false);
	m_long_label1->set_use_markup(false);
	m_long_label1->set_selectable(false);
	
	m_long_min_spinbutton->set_flags(Gtk::CAN_FOCUS);
	_tooltips.set_tip(*m_long_min_spinbutton, _("Longitude in minutes of your location"), "");
	//spinbutton1->add_accelerator("grab_focus", accgrp, GDK_o, Gdk::MOD1_MASK, Gtk::ACCEL_VISIBLE);
	m_long_min_spinbutton->set_update_policy(Gtk::UPDATE_ALWAYS);
	m_long_min_spinbutton->set_numeric(true);
	m_long_min_spinbutton->set_digits(0);
	m_long_min_spinbutton->set_wrap(true);
	
	m_long_label2->set_alignment(0.5,0.5);
	m_long_label2->set_padding(0,0);
	m_long_label2->set_justify(Gtk::JUSTIFY_LEFT);
	m_long_label2->set_line_wrap(false);
	m_long_label2->set_use_markup(false);
	m_long_label2->set_selectable(false);
	
	m_long_sec_spinbutton->set_flags(Gtk::CAN_FOCUS);
	_tooltips.set_tip(*m_long_sec_spinbutton, _("Longitude in seconds of your location"), "");
	//spinbutton2->add_accelerator("grab_focus", accgrp, GDK_o, Gdk::MOD1_MASK, Gtk::ACCEL_VISIBLE);
	m_long_sec_spinbutton->set_update_policy(Gtk::UPDATE_ALWAYS);
	m_long_sec_spinbutton->set_numeric(true);
	m_long_sec_spinbutton->set_digits(1);
	m_long_sec_spinbutton->set_wrap(true);
	
	m_long_hbox->pack_start(*m_long_deg_spinbutton);
	m_long_hbox->pack_start(*m_long_label1, Gtk::PACK_SHRINK, 0);
	m_long_hbox->pack_start(*m_long_min_spinbutton);
	m_long_hbox->pack_start(*m_long_label2, Gtk::PACK_SHRINK, 0);
	m_long_hbox->pack_start(*m_long_sec_spinbutton);
	
	m_elevation_spinbutton->set_flags(Gtk::CAN_FOCUS);
	_tooltips.set_tip(*m_elevation_spinbutton, _("Location height above sea level in metres"), "");
	//m_elevation_spinbutton->add_accelerator("grab_focus", accgrp, GDK_E, Gdk::MOD1_MASK, Gtk::ACCEL_VISIBLE);
	m_elevation_spinbutton->set_update_policy(Gtk::UPDATE_ALWAYS);
	m_elevation_spinbutton->set_numeric(true);
	m_elevation_spinbutton->set_digits(0);
	m_elevation_spinbutton->set_wrap(false);
	
	m_latitude_label->set_alignment(0.40,0.5);
	m_latitude_label->set_padding(0,0);
	m_latitude_label->set_justify(Gtk::JUSTIFY_LEFT);
	m_latitude_label->set_line_wrap(false);
	m_latitude_label->set_use_markup(true);
	m_latitude_label->set_selectable(false);
	m_latitude_label->set_mnemonic_widget(*m_lat_deg_spinbutton);
	
	m_longitude_label->set_alignment(0.45,0.5);
	m_longitude_label->set_padding(0,0);
	m_longitude_label->set_justify(Gtk::JUSTIFY_LEFT);
	m_longitude_label->set_line_wrap(false);
	m_longitude_label->set_use_markup(true);
	m_longitude_label->set_selectable(false);
	m_longitude_label->set_mnemonic_widget(*m_long_deg_spinbutton);
	
	m_elevation_label->set_alignment(0.35,0.5);
	m_elevation_label->set_padding(0,0);
	m_elevation_label->set_justify(Gtk::JUSTIFY_LEFT);
	m_elevation_label->set_line_wrap(false);
	m_elevation_label->set_use_markup(true);
	m_elevation_label->set_selectable(false);
	m_elevation_label->set_mnemonic_widget(*m_elevation_spinbutton);
	
	m_position_table->set_border_width(6);
	m_position_table->set_row_spacings(10);
	m_position_table->set_col_spacings(6);
	m_position_table->attach(*m_lat_hbox, 1, 2, 0, 1, Gtk::FILL, Gtk::FILL, 0, 0);
	m_position_table->attach(*m_long_hbox, 1, 2, 1, 2, Gtk::FILL, Gtk::FILL, 0, 0);
	m_position_table->attach(*m_elevation_spinbutton, 1, 2, 2, 3, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0);
	m_position_table->attach(*m_latitude_label, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0);
	m_position_table->attach(*m_longitude_label, 0, 1, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0);
	m_position_table->attach(*m_elevation_label, 0, 1, 2, 3, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0);
	
	m_location_vbox->set_border_width(6);
	m_location_vbox->set_spacing(6);
	m_location_vbox->pack_start(*m_location_label, Gtk::PACK_SHRINK, 0);
	m_location_vbox->pack_start(*m_name_hbox, Gtk::PACK_SHRINK, 0);
	m_location_vbox->pack_start(*m_position_label, Gtk::PACK_SHRINK, 0);
	m_location_vbox->pack_start(*m_position_table, Gtk::PACK_SHRINK, 0);

	m_posn_druidpage->set_title("Creating a new Sky View");
	m_posn_druidpage->get_vbox()->pack_start(*m_location_vbox);
	m_posn_druidpage->show_all();
	
	// connect signal handlers
	m_name_entry->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_name_entry_changed));
	m_lat_deg_spinbutton->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_lat_deg_spinbutton_changed));
	m_lat_min_spinbutton->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_lat_min_spinbutton_changed));
	m_lat_sec_spinbutton->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_lat_sec_spinbutton_changed));
	m_long_deg_spinbutton->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_long_deg_spinbutton_changed));
	m_long_min_spinbutton->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_long_min_spinbutton_changed));
	m_long_sec_spinbutton->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_long_sec_spinbutton_changed));
	m_elevation_spinbutton->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_elevation_spinbutton_changed));
}

/*! \fn void VSkyDruid::create_page_date (void)
* \bug The GnomeDateEdit is incorrectly displaying a time selector.
*
* Create the virtual sky druid date page.
*/
void VSkyDruid::create_page_date (void)
{
	time_t the_time;
	time (&the_time);
	Gtk::RadioButton::Group _RadioBGroup_m_sys_date_radiobutton;
	Gtk::Tooltips _tooltips;
	Glib::RefPtr<Gtk::AccelGroup> accgrp;
	
	m_date_time_vbox = Gtk::manage(new class Gtk::VBox());
	m_date_time_label = Gtk::manage(new class Gtk::Label(_("<b>Observing Date and Time</b>")));
	m_sys_date_radiobutton = Gtk::manage(new class Gtk::RadioButton(_RadioBGroup_m_sys_date_radiobutton, _("Use your _computers date and time"), true));
	m_another_date_radiobutton = Gtk::manage(new class Gtk::RadioButton(_RadioBGroup_m_sys_date_radiobutton, _("Use _another date and time"), true));
	m_date_time_table = Gtk::manage(new class Gtk::Table(2,2,false));
	m_day_spinbutton_adj = Gtk::manage(new class Gtk::Adjustment(1, 1, 31, 1, 10, 10));
	m_day_spinbutton = Gtk::manage(new class Gtk::SpinButton(*m_day_spinbutton_adj, 1, 0));
	m_date_label1 = Gtk::manage(new class Gtk::Label(_(":")));
	m_month_spinbutton_adj = Gtk::manage(new class Gtk::Adjustment(1, 1, 12, 1, 2, 2));
	m_month_spinbutton = Gtk::manage(new class Gtk::SpinButton(*m_month_spinbutton_adj, 1, 0));
	m_date_label2 = Gtk::manage(new class Gtk::Label(_(":")));
	m_year_spinbutton_adj = Gtk::manage(new class Gtk::Adjustment(2000, 0, 3000, 1, 10, 10));
	m_year_spinbutton = Gtk::manage(new class Gtk::SpinButton(*m_year_spinbutton_adj, 1, 0));
	m_date_hbox = Gtk::manage(new class Gtk::HBox(false, 0));
	m_hours_spinbutton_adj = Gtk::manage(new class Gtk::Adjustment(0, 0, 23, 1, 10, 10));
	m_hours_spinbutton = Gtk::manage(new class Gtk::SpinButton(*m_hours_spinbutton_adj, 1, 0));
	m_time_label1 = Gtk::manage(new class Gtk::Label(_(":")));
	m_minutes_spinbutton_adj = Gtk::manage(new class Gtk::Adjustment(0, 0, 59, 1, 10, 10));
	m_minutes_spinbutton = Gtk::manage(new class Gtk::SpinButton(*m_minutes_spinbutton_adj, 1, 0));
	m_time_label2 = Gtk::manage(new class Gtk::Label(_(":")));
	m_seconds_spinbutton_adj = Gtk::manage(new class Gtk::Adjustment(0, 0, 59.9, 1, 10, 10));
	m_seconds_spinbutton = Gtk::manage(new class Gtk::SpinButton(*m_seconds_spinbutton_adj, 1, 1));
	m_time_hbox = Gtk::manage(new class Gtk::HBox(false, 0));
	m_date_label = Gtk::manage(new class Gtk::Label(_("_Date (m:d:y)"), true));
	m_time_label = Gtk::manage(new class Gtk::Label(_("_Time (h:m:s)"), true));
	m_julian_day_radiobutton = Gtk::manage(new class Gtk::RadioButton(_RadioBGroup_m_sys_date_radiobutton, _("Use a _Julian day"), true));
	m_julian_label = Gtk::manage(new class Gtk::Label(_("J_ulian Day:"), true));
	m_julian_spinbutton_adj = Gtk::manage(new class Gtk::Adjustment(2.45e+06, 0, 3e+06, 1, 10, 10));
	m_julian_spinbutton = Gtk::manage(new class Gtk::SpinButton(*m_julian_spinbutton_adj, 1, 5));
	m_julian_hbox = Gtk::manage(new class Gtk::HBox(false, 6));
	m_date_time_druidpage = Gtk::manage(new Gnome::UI::DruidPageStandard());

	// page settings
	m_date_time_label->set_alignment(0,0.5);
	m_date_time_label->set_padding(0,6);
	m_date_time_label->set_justify(Gtk::JUSTIFY_LEFT);
	m_date_time_label->set_line_wrap(false);
	m_date_time_label->set_use_markup(true);
	m_date_time_label->set_selectable(false);
	
	m_sys_date_radiobutton->set_flags(Gtk::CAN_FOCUS);
	_tooltips.set_tip(*m_sys_date_radiobutton, _("Use the system date and time for the sky view"), "");
	//m_sys_date_radiobutton->add_accelerator("clicked", accgrp, GDK_c, Gdk::MOD1_MASK, Gtk::ACCEL_VISIBLE);
	m_sys_date_radiobutton->set_border_width(6);
	m_sys_date_radiobutton->set_relief(Gtk::RELIEF_NORMAL);
	m_sys_date_radiobutton->set_mode(true);
	m_sys_date_radiobutton->set_active(true);
	
	m_another_date_radiobutton->set_flags(Gtk::CAN_FOCUS);
	_tooltips.set_tip(*m_another_date_radiobutton, _("Use another date and time for the sky view"), "");
	//m_another_date_radiobutton->add_accelerator("clicked", accgrp, GDK_a, Gdk::MOD1_MASK, Gtk::ACCEL_VISIBLE);
	m_another_date_radiobutton->set_border_width(6);
	m_another_date_radiobutton->set_relief(Gtk::RELIEF_NORMAL);
	m_another_date_radiobutton->set_mode(true);
	m_another_date_radiobutton->set_active(false);
	
	m_day_spinbutton->set_flags(Gtk::CAN_FOCUS);
	_tooltips.set_tip(*m_day_spinbutton, _("Day of the Month"), "");
	//m_day_spinbutton->add_accelerator("grab_focus", gmm_data->getAccelGroup(), GDK_a, Gdk::MOD1_MASK, Gtk::ACCEL_VISIBLE);
	m_day_spinbutton->set_update_policy(Gtk::UPDATE_ALWAYS);
	m_day_spinbutton->set_numeric(true);
	m_day_spinbutton->set_digits(0);
	m_day_spinbutton->set_wrap(true);
	m_day_spinbutton->set_sensitive(false);
	m_day_spinbutton->set_value(m_date.days);
	
	m_date_label1->set_alignment(0.5,0.5);
	m_date_label1->set_padding(0,0);
	m_date_label1->set_justify(Gtk::JUSTIFY_LEFT);
	m_date_label1->set_line_wrap(false);
	m_date_label1->set_use_markup(false);
	m_date_label1->set_selectable(false);
	
	m_month_spinbutton->set_flags(Gtk::CAN_FOCUS);
	_tooltips.set_tip(*m_month_spinbutton, _("Month of the Year"), "");
	m_month_spinbutton->set_update_policy(Gtk::UPDATE_ALWAYS);
	m_month_spinbutton->set_numeric(true);
	m_month_spinbutton->set_digits(0);
	m_month_spinbutton->set_wrap(true);
	m_month_spinbutton->set_sensitive(false);
	m_month_spinbutton->set_value(m_date.months);
	
	m_date_label2->set_alignment(0.5,0.5);
	m_date_label2->set_padding(0,0);
	m_date_label2->set_justify(Gtk::JUSTIFY_LEFT);
	m_date_label2->set_line_wrap(false);
	m_date_label2->set_use_markup(false);
	m_date_label2->set_selectable(false);
	
	m_year_spinbutton->set_flags(Gtk::CAN_FOCUS);
	_tooltips.set_tip(*m_year_spinbutton, _("Year"), "");
	m_year_spinbutton->set_update_policy(Gtk::UPDATE_ALWAYS);
	m_year_spinbutton->set_numeric(true);
	m_year_spinbutton->set_digits(0);
	m_year_spinbutton->set_wrap(true);
	m_year_spinbutton->set_sensitive(false);
	m_year_spinbutton->set_value(m_date.years);
	
	m_date_hbox->pack_start(*m_day_spinbutton);
	m_date_hbox->pack_start(*m_date_label1, Gtk::PACK_SHRINK, 0);
	m_date_hbox->pack_start(*m_month_spinbutton);
	m_date_hbox->pack_start(*m_date_label2, Gtk::PACK_SHRINK, 0);
	m_date_hbox->pack_start(*m_year_spinbutton);
	
	m_hours_spinbutton->set_flags(Gtk::CAN_FOCUS);
	_tooltips.set_tip(*m_hours_spinbutton, _("Time in Hours"), "");
	//m_hours_spinbutton->add_accelerator("grab_focus", gmm_data->getAccelGroup(), GDK_a, Gdk::MOD1_MASK, Gtk::ACCEL_VISIBLE);
	m_hours_spinbutton->set_update_policy(Gtk::UPDATE_ALWAYS);
	m_hours_spinbutton->set_numeric(true);
	m_hours_spinbutton->set_digits(0);
	m_hours_spinbutton->set_wrap(true);
	m_hours_spinbutton->set_sensitive(false);
	m_hours_spinbutton->set_value(m_date.hours);
	
	m_time_label1->set_alignment(0.5,0.5);
	m_time_label1->set_padding(0,0);
	m_time_label1->set_justify(Gtk::JUSTIFY_LEFT);
	m_time_label1->set_line_wrap(false);
	m_time_label1->set_use_markup(false);
	m_time_label1->set_selectable(false);
	
	m_minutes_spinbutton->set_flags(Gtk::CAN_FOCUS);
	_tooltips.set_tip(*m_minutes_spinbutton, _("Time in Minutes"), "");
	m_minutes_spinbutton->set_update_policy(Gtk::UPDATE_ALWAYS);
	m_minutes_spinbutton->set_numeric(true);
	m_minutes_spinbutton->set_digits(0);
	m_minutes_spinbutton->set_wrap(true);
	m_minutes_spinbutton->set_sensitive(false);
	m_minutes_spinbutton->set_value(m_date.minutes);
	
	m_time_label2->set_alignment(0.5,0.5);
	m_time_label2->set_padding(0,0);
	m_time_label2->set_justify(Gtk::JUSTIFY_LEFT);
	m_time_label2->set_line_wrap(false);
	m_time_label2->set_use_markup(false);
	m_time_label2->set_selectable(false);
	
	m_seconds_spinbutton->set_flags(Gtk::CAN_FOCUS);
	_tooltips.set_tip(*m_seconds_spinbutton, _("Time in Seconds"), "");
	m_seconds_spinbutton->set_update_policy(Gtk::UPDATE_ALWAYS);
	m_seconds_spinbutton->set_numeric(true);
	m_seconds_spinbutton->set_digits(1);
	m_seconds_spinbutton->set_wrap(true);
	m_seconds_spinbutton->set_sensitive(false);
	m_seconds_spinbutton->set_value(m_date.seconds);
	
	m_time_hbox->pack_start(*m_hours_spinbutton);
	m_time_hbox->pack_start(*m_time_label1, Gtk::PACK_SHRINK, 0);
	m_time_hbox->pack_start(*m_minutes_spinbutton);
	m_time_hbox->pack_start(*m_time_label2, Gtk::PACK_SHRINK, 0);
	m_time_hbox->pack_start(*m_seconds_spinbutton);
	
	m_date_label->set_alignment(0.34,0.5);
	m_date_label->set_padding(0,0);
	m_date_label->set_justify(Gtk::JUSTIFY_LEFT);
	m_date_label->set_line_wrap(false);
	m_date_label->set_use_markup(true);
	m_date_label->set_selectable(false);
	
	m_time_label->set_alignment(0.34,0.5);
	m_time_label->set_padding(0,0);
	m_time_label->set_justify(Gtk::JUSTIFY_LEFT);
	m_time_label->set_line_wrap(false);
	m_time_label->set_use_markup(true);
	m_time_label->set_selectable(false);
	
	m_date_time_table->set_border_width(6);
	m_date_time_table->set_row_spacings(10);
	m_date_time_table->set_col_spacings(6);
	m_date_time_table->attach(*m_date_hbox, 1, 2, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0);
	m_date_time_table->attach(*m_time_hbox, 1, 2, 1, 2, Gtk::FILL, Gtk::FILL, 0, 0);
	m_date_time_table->attach(*m_date_label, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0);
	m_date_time_table->attach(*m_time_label, 0, 1, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0);
	
	m_julian_day_radiobutton->set_flags(Gtk::CAN_FOCUS);
	_tooltips.set_tip(*m_julian_day_radiobutton, _("Use a Julian day for the sky view"), "");
	//m_julian_day_radiobutton->add_accelerator("clicked", accgrp, GDK_J, Gdk::MOD1_MASK, Gtk::ACCEL_VISIBLE);
	m_julian_day_radiobutton->set_border_width(6);
	m_julian_day_radiobutton->set_relief(Gtk::RELIEF_NORMAL);
	m_julian_day_radiobutton->set_mode(true);
	m_julian_day_radiobutton->set_active(false);
	
	m_julian_label->set_alignment(0.26,0.5);
	m_julian_label->set_padding(0,0);
	m_julian_label->set_justify(Gtk::JUSTIFY_LEFT);
	m_julian_label->set_line_wrap(false);
	m_julian_label->set_use_markup(true);
	m_julian_label->set_selectable(false);
	m_julian_label->set_mnemonic_widget(*m_julian_spinbutton);
	
	m_julian_spinbutton->set_flags(Gtk::CAN_FOCUS);
	_tooltips.set_tip(*m_julian_spinbutton, _("Julian day"), "");
	//m_julian_spinbutton->add_accelerator("grab_focus", accgrp, GDK_u, Gdk::MOD1_MASK, Gtk::ACCEL_VISIBLE);
	m_julian_spinbutton->set_update_policy(Gtk::UPDATE_ALWAYS);
	m_julian_spinbutton->set_numeric(true);
	m_julian_spinbutton->set_digits(3);
	m_julian_spinbutton->set_wrap(false);
	m_julian_spinbutton->set_sensitive(false);
	m_julian_spinbutton->set_value(m_JD);
	
	m_julian_hbox->set_border_width(6);
	m_julian_hbox->pack_start(*m_julian_label);
	m_julian_hbox->pack_start(*m_julian_spinbutton);
	
	m_date_time_vbox->set_border_width(6);
	m_date_time_vbox->pack_start(*m_date_time_label, Gtk::PACK_SHRINK, 0);
	m_date_time_vbox->pack_start(*m_sys_date_radiobutton, Gtk::PACK_SHRINK, 0);
	m_date_time_vbox->pack_start(*m_another_date_radiobutton, Gtk::PACK_SHRINK, 0);
	m_date_time_vbox->pack_start(*m_date_time_table, Gtk::PACK_SHRINK, 0);
	m_date_time_vbox->pack_start(*m_julian_day_radiobutton, Gtk::PACK_SHRINK, 0);
	m_date_time_vbox->pack_start(*m_julian_hbox, Gtk::PACK_SHRINK, 0);
	
	m_date_time_druidpage->set_title("Creating a new Sky View");
	m_date_time_druidpage->get_vbox()->pack_start(*m_date_time_vbox);
	m_date_time_druidpage->show_all();
	
	//connect signal handlers
	m_sys_date_radiobutton->signal_toggled().connect(SigC::slot(*this, &VSkyDruid::on_sys_date_radiobutton_toggled));
	m_another_date_radiobutton->signal_toggled().connect(SigC::slot(*this, &VSkyDruid::on_another_date_radiobutton_toggled));
	m_days_changed = m_day_spinbutton->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_day_spinbutton_changed));
	m_months_changed = m_month_spinbutton->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_month_spinbutton_changed));
	m_years_changed = m_year_spinbutton->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_year_spinbutton_changed));
	m_hours_changed = m_hours_spinbutton->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_hours_spinbutton_changed));
	m_minutes_changed = m_minutes_spinbutton->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_minutes_spinbutton_changed));
	m_seconds_changed = m_seconds_spinbutton->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_seconds_spinbutton_changed));
	m_julian_day_radiobutton->signal_toggled().connect(SigC::slot(*this, &VSkyDruid::on_julian_day_radiobutton_toggled));
	m_julian_changed = m_julian_spinbutton->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_julian_spinbutton_changed));
}


/*! \fn void VSkyDruid::create_page_epoch (void)
*
* Create the virtual sky druid epoch page.
*/
void VSkyDruid::create_page_zone (void)
{	
	// create page widgets
	Gtk::Tooltips _tooltips;
	Glib::RefPtr<Gtk::AccelGroup> accgrp;
	m_zone_label = Gtk::manage(new class Gtk::Label(_("<b>Observing Timezone</b>")));
	Gtk::RadioButton::Group _RadioBGroup_m_sys_zone_radiobutton;
	m_sys_zone_radiobutton = Gtk::manage(new class Gtk::RadioButton(_RadioBGroup_m_sys_zone_radiobutton, _("Use the timezone from your _computer."), true));
	m_another_zone_radiobutton = Gtk::manage(new class Gtk::RadioButton(_RadioBGroup_m_sys_zone_radiobutton, _("Use _another timezone"), true));
	m_timezone_label = Gtk::manage(new class Gtk::Label(_("_Timezone"), true));
	m_zone_combo = Gtk::manage(new class Gtk::Combo());
	m_zone_hbox = Gtk::manage(new class Gtk::HBox(false, 6));
	m_zone_vbox = Gtk::manage(new Gtk::VBox(false, 6));
	m_timezone_druidpage = Gtk::manage(new Gnome::UI::DruidPageStandard());

	// page settings
	m_zone_label->set_alignment(0,0.5);
	m_zone_label->set_padding(0,6);
	m_zone_label->set_justify(Gtk::JUSTIFY_LEFT);
	m_zone_label->set_line_wrap(false);
	m_zone_label->set_use_markup(true);
	m_zone_label->set_selectable(false);
	
	m_sys_zone_radiobutton->set_flags(Gtk::CAN_FOCUS);
	_tooltips.set_tip(*m_sys_zone_radiobutton, _("Use the system timezone for the sky view"), "");
	//m_sys_zone_radiobutton->add_accelerator("clicked", accgrp, GDK_c, Gdk::MOD1_MASK, Gtk::ACCEL_VISIBLE);
	m_sys_zone_radiobutton->set_border_width(6);
	m_sys_zone_radiobutton->set_relief(Gtk::RELIEF_NORMAL);
	m_sys_zone_radiobutton->set_mode(true);
	m_sys_zone_radiobutton->set_active(true);
	
	m_another_zone_radiobutton->set_flags(Gtk::CAN_FOCUS);
	_tooltips.set_tip(*m_another_zone_radiobutton, _("Use another timezone for the sky view"), "");
	//m_another_zone_radiobutton->add_accelerator("clicked", accgrp, GDK_a, Gdk::MOD1_MASK, Gtk::ACCEL_VISIBLE);
	m_another_zone_radiobutton->set_border_width(6);
	m_another_zone_radiobutton->set_relief(Gtk::RELIEF_NORMAL);
	m_another_zone_radiobutton->set_mode(true);
	m_another_zone_radiobutton->set_active(false);
	
	m_timezone_label->set_alignment(0.5,0.5);
	m_timezone_label->set_padding(0,0);
	m_timezone_label->set_justify(Gtk::JUSTIFY_LEFT);
	m_timezone_label->set_line_wrap(false);
	m_timezone_label->set_use_markup(true);
	m_timezone_label->set_selectable(false);
//	m_timezone_label->set_mnemonic_widget(*m_zone_combo_entry);
	
	m_zone_combo->get_entry()->set_flags(Gtk::CAN_FOCUS);
	_tooltips.set_tip(*m_zone_combo->get_entry(), _("Sky view timezone"), "");
	//m_zone_combo->get_entry()->add_accelerator("grab_focus", accgrp, GDK_T, Gdk::MOD1_MASK, Gtk::ACCEL_VISIBLE);
	m_zone_combo->get_entry()->set_visibility(true);
	m_zone_combo->get_entry()->set_editable(false);
	m_zone_combo->get_entry()->set_max_length(0);
	m_zone_combo->get_entry()->set_has_frame(true);
	m_zone_combo->get_entry()->set_activates_default(false);
	m_zone_combo->set_case_sensitive(false);
	m_zone_combo->set_sensitive(false);
	{	
	  const char * const items[] = { 
		  "GMT - 11", 
		  "GMT - 10", 
		  "GMT - 9", 
		  "GMT - 8", 
		  "GMT - 7", 
		  "GMT - 6", 
		  "GMT - 5", 
		  "GMT - 4", 
		  "GMT - 3", 
		  "GMT - 2", 
		  "GMT - 1", 
		  "GMT (London, UK)", 
		  "GMT + 1",
		  "GMT + 2",
		  "GMT + 3",
		  "GMT + 4",
		  "GMT + 5",
		  "GMT + 6",
		  "GMT + 7",
		  "GMT + 8",
		  "GMT + 9",
		  "GMT + 10",
		  "GMT + 11",
		  0 };
		  m_zone_combo->set_popdown_strings(items);
	 }
	 m_zone_combo->get_entry()->set_text(_("GMT (London, UK)"));
	 
	m_zone_hbox->set_border_width(6);
	m_zone_hbox->pack_start(*m_timezone_label, Gtk::PACK_EXPAND_PADDING, 0);
	m_zone_hbox->pack_start(*m_zone_combo);
	
	m_zone_vbox->set_border_width(6);
	m_zone_vbox->pack_start(*m_zone_label, Gtk::PACK_SHRINK, 0);
	m_zone_vbox->pack_start(*m_sys_zone_radiobutton, Gtk::PACK_SHRINK, 0);
	m_zone_vbox->pack_start(*m_another_zone_radiobutton, Gtk::PACK_SHRINK, 0);
	m_zone_vbox->pack_start(*m_zone_hbox, Gtk::PACK_SHRINK, 0);
	
	m_timezone_druidpage->set_title("Creating a new Sky View");
	m_timezone_druidpage->get_vbox()->pack_start(*m_zone_vbox);
	m_timezone_druidpage->show_all();
	
	// connect signal handlers
	m_sys_zone_radiobutton->signal_toggled().connect(SigC::slot(*this, &VSkyDruid::on_sys_zone_radiobutton_toggled));
	m_another_zone_radiobutton->signal_toggled().connect(SigC::slot(*this, &VSkyDruid::on_another_zone_radiobutton_toggled));
	m_zone_combo->get_entry()->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_zone_combo_entry_changed));
}

/*! \fn void VSkyDruid::create_page_finish (void)
* 
* Create the virtual sky druid finish page.
*/
void VSkyDruid::create_page_finish (void)
{
	// create page 
	m_vsky_druidpagefinish = Gtk::manage(new Gnome::UI::DruidPageEdge(Gnome::UI::EDGE_FINISH));
	
	// page settings
	m_vsky_druidpagefinish->set_title_color(Gdk::Color("#ffffff"));
	m_vsky_druidpagefinish->set_logo_bg_color(Gdk::Color("#ffffff"));
	m_vsky_druidpagefinish->set_title(  ("Sky View complete"));
	m_vsky_druidpagefinish->set_text_color(Gdk::Color("#000000"));
	m_vsky_druidpagefinish->set_textbox_color(Gdk::Color("#ffffff"));
	m_vsky_druidpagefinish->set_text(  ("Click 'Apply' to display the new sky view.\n\nThe sky settings can be changed from the Sky menu."));
	
	// connect signal handler
	m_vsky_druidpagefinish->signal_finish().connect(SigC::slot(*this, &VSkyDruid::on_vsky_druidpagefinish_finish));
}

void VSkyDruid::on_name_entry_changed()
{  
	Glib::ustring name = m_name_entry->get_text();
	m_vsky->set_location(name);
}

void VSkyDruid::on_lat_deg_spinbutton_changed()
{  
	double latitude;
	
	m_lat.degrees = (int)m_lat_deg_spinbutton->get_value();
	latitude = ln_dms_to_deg(&m_lat);
	m_vsky->set_latitude(latitude);
}

void VSkyDruid::on_lat_min_spinbutton_changed()
{
	double latitude;
	
	m_lat.minutes = (int)m_lat_min_spinbutton->get_value();
	latitude = ln_dms_to_deg(&m_lat);
	m_vsky->set_latitude(latitude);	
}

void VSkyDruid::on_lat_sec_spinbutton_changed()
{  
	double latitude;
	
	m_lat.seconds = m_lat_sec_spinbutton->get_value();
	latitude = ln_dms_to_deg(&m_lat);
	m_vsky->set_latitude(latitude);
}

void VSkyDruid::on_long_deg_spinbutton_changed()
{  
	double longitude;
	
	m_long.degrees = (int)m_long_deg_spinbutton->get_value();
	longitude = ln_dms_to_deg(&m_long);
	m_vsky->set_longitude(longitude);
}

void VSkyDruid::on_long_min_spinbutton_changed()
{  
	double longitude;
	
	m_long.minutes = (int)m_long_min_spinbutton->get_value();
	longitude = ln_dms_to_deg(&m_long);
	m_vsky->set_longitude(longitude);
}

void VSkyDruid::on_long_sec_spinbutton_changed()
{  
	double longitude;
	
	m_long.seconds = m_long_sec_spinbutton->get_value();
	longitude = ln_dms_to_deg(&m_long);
	m_vsky->set_longitude(longitude);
}

void VSkyDruid::on_elevation_spinbutton_changed()
{  
	m_vsky->set_elevation(m_elevation_spinbutton->get_value());
}

void VSkyDruid::on_sys_date_radiobutton_toggled()
{  
	double JD;
	
	m_years_changed.disconnect();
	m_months_changed.disconnect();
	m_days_changed.disconnect();
	m_hours_changed.disconnect();
	m_minutes_changed.disconnect();
	m_seconds_changed.disconnect();
	m_julian_changed.disconnect();
	
	m_year_spinbutton->set_sensitive(false);
	m_month_spinbutton->set_sensitive(false);
	m_day_spinbutton->set_sensitive(false);
	m_hours_spinbutton->set_sensitive(false);
	m_minutes_spinbutton->set_sensitive(false);
	m_seconds_spinbutton->set_sensitive(false);
	m_julian_spinbutton->set_sensitive(false);
	m_use_sys_date = true;
	m_use_another_date = false;
	m_use_julian_date = false;
	
	refresh_date();
	m_vsky->set_jd(m_JD);
	m_vsky->set_live(true);
}

void VSkyDruid::on_another_date_radiobutton_toggled()
{  
	m_julian_changed.disconnect();

	m_days_changed = m_day_spinbutton->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_day_spinbutton_changed));
	m_months_changed = m_month_spinbutton->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_month_spinbutton_changed));
	m_years_changed = m_year_spinbutton->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_year_spinbutton_changed));
	m_hours_changed = m_hours_spinbutton->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_hours_spinbutton_changed));
	m_minutes_changed = m_minutes_spinbutton->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_minutes_spinbutton_changed));
	m_seconds_changed = m_seconds_spinbutton->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_seconds_spinbutton_changed));

	m_year_spinbutton->set_sensitive(true);
	m_month_spinbutton->set_sensitive(true);
	m_day_spinbutton->set_sensitive(true);
	m_hours_spinbutton->set_sensitive(true);
	m_minutes_spinbutton->set_sensitive(true);
	m_seconds_spinbutton->set_sensitive(true);
	m_julian_spinbutton->set_sensitive(false);
	m_use_sys_date = false;
	m_use_another_date = true;
	m_use_julian_date = false;
	refresh_date();
	m_vsky->set_live(false);
}

void VSkyDruid::on_year_spinbutton_changed()
{
	double JD;
	
	m_date.years = (int)m_year_spinbutton->get_value();
	refresh_date();
	JD = ln_get_julian_day(&m_date);
	m_vsky->set_jd(JD);
}

void VSkyDruid::on_month_spinbutton_changed()
{
	double JD;
	
	m_date.months = (int)m_month_spinbutton->get_value();
	refresh_date();
	JD = ln_get_julian_day(&m_date);
	m_vsky->set_jd(JD);
}

void VSkyDruid::on_day_spinbutton_changed()
{
	double JD;
	
	m_date.days = (int)m_day_spinbutton->get_value();
	refresh_date();
	JD = ln_get_julian_day(&m_date);
	m_vsky->set_jd(JD);
}

void VSkyDruid::on_hours_spinbutton_changed()
{ 
	double JD;
	
	m_date.hours = (int)m_hours_spinbutton->get_value();
	refresh_date();	
	JD = ln_get_julian_day(&m_date);
	m_vsky->set_jd(JD);
}

void VSkyDruid::on_minutes_spinbutton_changed()
{  
	double JD;
	
	m_date.minutes = (int)m_minutes_spinbutton->get_value();
	refresh_date();
	JD = ln_get_julian_day(&m_date);
	m_vsky->set_jd(JD);
}

void VSkyDruid::on_seconds_spinbutton_changed()
{  
	double JD;
	
	m_date.seconds = m_seconds_spinbutton->get_value();
	refresh_date();
	JD = ln_get_julian_day(&m_date);
	m_vsky->set_jd(JD);
}

void VSkyDruid::on_julian_spinbutton_changed()
{  
	double JD;
	
	m_JD = m_julian_spinbutton->get_value();
	refresh_date();
	JD = ln_get_julian_day(&m_date);
	m_vsky->set_jd(JD);
}

void VSkyDruid::on_julian_day_radiobutton_toggled()
{
	double JD;
	
	m_years_changed.disconnect();
	m_months_changed.disconnect();
	m_days_changed.disconnect();
	m_hours_changed.disconnect();
	m_minutes_changed.disconnect();
	m_seconds_changed.disconnect();
	m_julian_changed = m_julian_spinbutton->signal_changed().connect(SigC::slot(*this, &VSkyDruid::on_julian_spinbutton_changed));
	
	m_year_spinbutton->set_sensitive(false);
	m_month_spinbutton->set_sensitive(false);
	m_day_spinbutton->set_sensitive(false);
	m_hours_spinbutton->set_sensitive(false);
	m_minutes_spinbutton->set_sensitive(false);
	m_seconds_spinbutton->set_sensitive(false);
	m_julian_spinbutton->set_sensitive(true);
	m_use_sys_date = false;
	m_use_another_date = false;
	m_use_julian_date = true;
	refresh_date();	
	JD = ln_get_julian_day(&m_date);
	m_vsky->set_jd(JD);
}

void VSkyDruid::on_sys_zone_radiobutton_toggled()
{  
	m_zone_combo->set_sensitive(false);
}

void VSkyDruid::on_another_zone_radiobutton_toggled()
{  
	m_zone_combo->set_sensitive(true);
}

void VSkyDruid::on_zone_combo_entry_changed()
{  
}

void VSkyDruid::on_vsky_druidpagefinish_finish(Gtk::Widget& druid)
{  
	hide();
	response(Gtk::RESPONSE_OK); //stops run().
}

void VSkyDruid::on_vsky_druid_cancel()
{  
	hide();
	response(Gtk::RESPONSE_CANCEL); //stops run().
}

void VSkyDruid::on_vsky_druid_help()
{  
	TodoDialog::display();
}

void VSkyDruid::refresh_date()
{	
	if (m_use_sys_date) {
		ln_get_date_from_sys(&m_date);
		m_JD = ln_get_julian_from_sys();
		
		m_year_spinbutton->set_value(m_date.years);
		m_month_spinbutton->set_value(m_date.months);
		m_day_spinbutton->set_value(m_date.days);
		m_hours_spinbutton->set_value(m_date.hours);
		m_minutes_spinbutton->set_value(m_date.minutes);
		m_seconds_spinbutton->set_value(m_date.seconds);
		m_julian_spinbutton->set_value(m_JD);
		
	} else if (m_use_another_date) {
		
		m_JD = ln_get_julian_day(&m_date);
		m_julian_spinbutton->set_value(m_JD);
	
	} else {
		ln_get_date(m_JD, &m_date);
		
		m_year_spinbutton->set_value(m_date.years);
		m_month_spinbutton->set_value(m_date.months);
		m_day_spinbutton->set_value(m_date.days);
		m_hours_spinbutton->set_value(m_date.hours);
		m_minutes_spinbutton->set_value(m_date.minutes);
		m_seconds_spinbutton->set_value(m_date.seconds);
		
	}
}

};