static void
gnome_druid_remove (GtkContainer *widget,
GtkWidget *child)
{
GnomeDruid *druid;
GList *list;
g_return_if_fail (widget != NULL);
g_return_if_fail (GNOME_IS_DRUID (widget));
g_return_if_fail (child != NULL);
druid = GNOME_DRUID (widget);
list = g_list_find (druid->_priv->children, child);
/* Is it a page? */
if (list != NULL) {
/* If we are mapped and visible, we want to deal with changing the page. */
if ((GTK_WIDGET_MAPPED (GTK_WIDGET (widget))) &&
(list->data == (gpointer) druid->_priv->current)) {
if (list->next != NULL)
gnome_druid_set_page (druid, GNOME_DRUID_PAGE (list->next->data));
else if (list->prev != NULL)
gnome_druid_set_page (druid, GNOME_DRUID_PAGE (list->prev->data));
else
/* Removing the only child, just set current to NULL */
druid->_priv->current = NULL;
}
}
druid->_priv->children = g_list_remove (druid->_priv->children, child);
gtk_widget_unparent (child);
}
static void
gb_gnome_druid_insert_page_before (GtkWidget * menuitem,
GnomeDruidPage *page)
{
GtkWidget *parent, *new_page;
GnomeDruidPage *prev_page;
GList *children, *elem;
parent = GTK_WIDGET (page)->parent;
g_return_if_fail (GNOME_IS_DRUID (parent));
children = gtk_container_get_children (GTK_CONTAINER (parent));
elem = g_list_find (children, page);
g_return_if_fail (elem != NULL);
new_page = gb_widget_new ("GnomeDruidPageStandard", parent);
gtk_widget_show_all (new_page);
if (elem->prev)
prev_page = GNOME_DRUID_PAGE (elem->prev->data);
else
prev_page = NULL;
g_list_free (children);
gnome_druid_insert_page (GNOME_DRUID (parent), prev_page,
GNOME_DRUID_PAGE (new_page));
gb_gnome_druid_show_page (parent, new_page);
gnome_druid_set_page (GNOME_DRUID (parent), GNOME_DRUID_PAGE (new_page));
tree_add_widget (GTK_WIDGET (new_page));
}
/**
* gnome_druid_set_page:
* @druid: A #GnomeDruid widget.
* @page: The #GnomeDruidPage to be brought to the foreground.
*
* Description: This will make @page the currently showing page in the druid.
* @page must already be in the druid.
**/
void
gnome_druid_set_page (GnomeDruid *druid,
GnomeDruidPage *page)
{
GList *list;
GtkWidget *old = NULL;
g_return_if_fail (druid != NULL);
g_return_if_fail (GNOME_IS_DRUID (druid));
g_return_if_fail (page != NULL);
g_return_if_fail (GNOME_IS_DRUID_PAGE (page));
if (druid->_priv->current == page)
return;
list = g_list_find (druid->_priv->children, page);
g_return_if_fail (list != NULL);
if ((druid->_priv->current) && (GTK_WIDGET_VISIBLE (druid->_priv->current)) && (GTK_WIDGET_MAPPED (druid))) {
old = GTK_WIDGET (druid->_priv->current);
}
druid->_priv->current = GNOME_DRUID_PAGE (list->data);
gnome_druid_page_prepare (druid->_priv->current);
if (GTK_WIDGET_VISIBLE (druid->_priv->current) && (GTK_WIDGET_MAPPED (druid))) {
gtk_widget_map (GTK_WIDGET (druid->_priv->current));
gtk_widget_set_sensitive (GTK_WIDGET (druid->_priv->current), TRUE);
}
if (old && GTK_WIDGET_MAPPED (old)) {
gtk_widget_unmap (old);
gtk_widget_set_sensitive (old, FALSE);
}
}
/*--------------------------------------------------------------------------*/
static void
add_finish_page( GnomeDruid *wdruid, GdkPixbuf *logo )
{
GdkColor druid_bg_color = DRUID_BG_COLOR;
GdkColor druid_title_color = DRUID_TITLE_COLOR;
gb_debug (DEBUG_UPDATE, "START");
finish_page = gnome_druid_page_edge_new_with_vals (GNOME_EDGE_FINISH,
TRUE,
_("done"),
_("Done."),
logo,
NULL,
NULL);
gnome_druid_page_edge_set_bg_color(GNOME_DRUID_PAGE_EDGE(finish_page),
&druid_bg_color);
gnome_druid_page_edge_set_logo_bg_color (GNOME_DRUID_PAGE_EDGE(finish_page),
&druid_bg_color );
gnome_druid_page_edge_set_title_color (GNOME_DRUID_PAGE_EDGE(finish_page),
&druid_title_color );
gnome_druid_append_page( wdruid, GNOME_DRUID_PAGE(finish_page) );
g_signal_connect_after( G_OBJECT(finish_page), "prepare",
G_CALLBACK(prepare_finish_page), NULL );
g_signal_connect( G_OBJECT(finish_page), "finish",
G_CALLBACK(finish_cb), NULL );
gb_debug (DEBUG_UPDATE, "END");
}
void
gb_gnome_druid_add_child (GtkWidget *widget,
GtkWidget *child,
GbWidgetSetArgData *data)
{
gnome_druid_append_page (GNOME_DRUID (widget), GNOME_DRUID_PAGE (child));
}
static void
gnome_druid_next_callback (GtkWidget *button, GnomeDruid *druid)
{
GList *list;
g_return_if_fail (druid->_priv->current != NULL);
if (druid->_priv->show_finish == FALSE) {
if (gnome_druid_page_next (druid->_priv->current))
return;
/* Make sure that we have a next list item */
list = g_list_find (druid->_priv->children,
druid->_priv->current);
/* this would be a bug */
g_assert (list != NULL);
list = list->next;
while (list != NULL &&
! GTK_WIDGET_VISIBLE (list->data))
list = list->next;
if ( ! list)
return;
gnome_druid_set_page (druid, GNOME_DRUID_PAGE (list->data));
} else {
gnome_druid_page_finish (druid->_priv->current);
}
}
/*--------------------------------------------------------------------------*/
static void
no_download( void )
{
gchar *date_min, *date_max, *finish_msg;
gbTableModel *table_model;
gb_debug (DEBUG_UPDATE, "START");
/* customize finish page for this outcome */
gnome_druid_page_edge_set_title( GNOME_DRUID_PAGE_EDGE(finish_page),
_( "No new data available" ) );
table_model = gb_table_get_model ();
date_min = gb_date_fmt (gb_table_model_get_rdate_min (table_model));
date_max = gb_date_fmt (gb_table_model_get_rdate_max (table_model));
finish_msg = g_strdup_printf(
_( "No new redemption data available from selected\n"
"download site.\n\n"
"GBonds is still configured with redemption data\n"
"for %s - %s.\n" ),
date_min, date_max );
gnome_druid_page_edge_set_text( GNOME_DRUID_PAGE_EDGE(finish_page), finish_msg );
g_free( date_min );
g_free( date_max );
g_free( finish_msg );
remote_dir_handle = NULL;
/* Now jump to the finish page */
gnome_druid_set_page( GNOME_DRUID(update_druid),
GNOME_DRUID_PAGE(finish_page) );
gb_debug (DEBUG_UPDATE, "END");
}
static void
gb_gnome_druid_add_finish_page (GtkWidget * menuitem,
GnomeDruid *druid)
{
GtkWidget *new_page;
new_page = gnome_druid_page_edge_new_aa (GNOME_EDGE_FINISH);
gb_widget_create_from (new_page, "GnomeDruidPageFinish");
gtk_widget_show_all (new_page);
gnome_druid_append_page (druid, GNOME_DRUID_PAGE (new_page));
gb_gnome_druid_show_page (GTK_WIDGET (druid), new_page);
gnome_druid_set_page (druid, GNOME_DRUID_PAGE (new_page));
tree_add_widget (GTK_WIDGET (new_page));
}
static void
on_druid_dialog_ok (GtkWidget * widget, GbWidgetNewData * data)
{
GtkWidget *new_widget, *spinbutton, *window, *page;
gint pages, i;
window = gtk_widget_get_toplevel (widget);
/* Only call callback if placeholder/fixed widget is still there */
if (gb_widget_can_finish_new (data))
{
spinbutton = gtk_object_get_data (GTK_OBJECT (window), "pages");
g_return_if_fail (spinbutton != NULL);
pages = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinbutton));
new_widget = gnome_druid_new ();
page = gnome_druid_page_edge_new_aa (GNOME_EDGE_START);
gb_widget_create_from (page, "GnomeDruidPageStart");
gnome_druid_append_page (GNOME_DRUID (new_widget),
GNOME_DRUID_PAGE (page));
gnome_druid_set_page (GNOME_DRUID (new_widget), GNOME_DRUID_PAGE (page));
for (i = 0; i < pages - 2; i++)
{
page = gb_widget_new ("GnomeDruidPageStandard", new_widget);
gnome_druid_append_page (GNOME_DRUID (new_widget),
GNOME_DRUID_PAGE (page));
}
if (pages >= 2)
{
page = gnome_druid_page_edge_new_aa (GNOME_EDGE_FINISH);
gb_widget_create_from (page, "GnomeDruidPageFinish");
gnome_druid_append_page (GNOME_DRUID (new_widget),
GNOME_DRUID_PAGE (page));
}
gtk_widget_show_all (new_widget);
gb_widget_initialize (new_widget, data);
(*data->callback) (new_widget, data);
}
gtk_widget_destroy (window);
}
static void
gnome_druid_add (GtkContainer *widget,
GtkWidget *page)
{
g_return_if_fail (widget != NULL);
g_return_if_fail (GNOME_IS_DRUID (widget));
g_return_if_fail (page != NULL);
g_return_if_fail (GNOME_IS_DRUID_PAGE (page));
gnome_druid_append_page (GNOME_DRUID (widget), GNOME_DRUID_PAGE (page));
}
static void
gb_gnome_druid_insert_page_after (GtkWidget * menuitem,
GnomeDruidPage *page)
{
GtkWidget *parent, *new_page;
parent = GTK_WIDGET (page)->parent;
g_return_if_fail (GNOME_IS_DRUID (parent));
new_page = gb_widget_new ("GnomeDruidPageStandard", parent);
gtk_widget_show_all (new_page);
gnome_druid_insert_page (GNOME_DRUID (parent),
GNOME_DRUID_PAGE (page),
GNOME_DRUID_PAGE (new_page));
gb_gnome_druid_show_page (parent, new_page);
gnome_druid_set_page (GNOME_DRUID (parent), GNOME_DRUID_PAGE (new_page));
tree_add_widget (GTK_WIDGET (new_page));
}
/*--------------------------------------------------------------------------*/
static void
add_select_download_page( GnomeDruid *wdruid, GdkPixbuf *logo )
{
GtkWidget *wvbox;
GdkColor druid_bg_color = DRUID_BG_COLOR;
GdkColor druid_title_color = DRUID_TITLE_COLOR;
GtkWidget *whbox, *wcombo;
GList *name_list = NULL;
GList *p;
Site *site;
gb_debug (DEBUG_UPDATE, "START");
download_page = gnome_druid_page_standard_new_with_vals (_("Select download site"),
logo,
NULL);
gnome_druid_page_standard_set_background(GNOME_DRUID_PAGE_STANDARD(download_page),
&druid_bg_color);
gnome_druid_page_standard_set_logo_background(GNOME_DRUID_PAGE_STANDARD(download_page),
&druid_bg_color);
gnome_druid_page_standard_set_title_foreground( GNOME_DRUID_PAGE_STANDARD(download_page),
&druid_title_color);
gnome_druid_append_page( wdruid, GNOME_DRUID_PAGE(download_page) );
wvbox = GNOME_DRUID_PAGE_STANDARD(download_page)->vbox;
whbox = gtk_hbox_new( FALSE, 10 );
gtk_container_set_border_width( GTK_CONTAINER(whbox), 20 );
gtk_box_pack_start( GTK_BOX(wvbox), whbox, TRUE, TRUE, 0 );
gtk_box_pack_start( GTK_BOX(whbox),
gtk_label_new( _("Download site:") ),
FALSE, TRUE, 0 );
if ( site_list == NULL ) {
site_list = read_site_list();
}
for ( p=site_list; p!= NULL; p=p->next ) {
site = (Site *)p->data;
name_list = g_list_append( name_list, site->name );
}
wcombo = gtk_combo_new();
gtk_combo_set_popdown_strings( GTK_COMBO(wcombo), name_list );
g_list_free( name_list );
name_list = NULL;
site_entry = GTK_COMBO(wcombo)->entry;
gtk_entry_set_editable( GTK_ENTRY(site_entry), FALSE );
gtk_box_pack_start( GTK_BOX(whbox), wcombo, TRUE, TRUE, 0 );
gb_debug (DEBUG_UPDATE, "END");
}
gboolean
on_userlist_import_page_1_next (GnomeDruidPage * druidpage, GtkWidget * widget, gpointer user_data)
{
GtkWidget *radio_import_server, *radio_import_file;
GnomeDruid *druid = GNOME_DRUID (glade_xml_get_widget (gladexml_import_userlist, "ImportUserlistDruid"));
GnomeDruidPage *page_last = GNOME_DRUID_PAGE (glade_xml_get_widget (gladexml_import_userlist, "userlist_import_page_last"));
radio_import_server = glade_xml_get_widget (gladexml_import_userlist, "RadioImportServer");
radio_import_file = glade_xml_get_widget (gladexml_import_userlist, "RadioImportFile");
g_assert (radio_import_file);
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (radio_import_server)))
{
GtkWidget *progress_window;
if (!gnomegadu_gadugadu_session)
{
GtkDialog *msgdialog = gtk_message_dialog_new_with_markup (NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
"<span weight=\"bold\"size=\"larger\">Brak połączenia</span>\n\nPołącz się z siecią Gadu-Gadu i spróbuj ponownie.");
gtk_dialog_run (GTK_DIALOG (msgdialog));
gtk_widget_destroy (GTK_WIDGET (msgdialog));
return TRUE;
}
gladexml_import_userlist_progress = glade_xml_new (PACKAGE_DATA_DIR "/gnomegadu.glade", "ImportUserlistServerProgressWindow", NULL);
glade_xml_signal_autoconnect (gladexml_import_userlist_progress);
g_assert (gladexml_import_userlist_progress);
progress_window = glade_xml_get_widget (gladexml_import_userlist_progress, "ImportUserlistServerProgressWindow");
g_assert(progress_window);
gtk_widget_show_all (GTK_WIDGET(progress_window));
gg_userlist_request (gnomegadu_gadugadu_session, GG_USERLIST_GET, NULL);
gnome_druid_set_page (druid, page_last);
gnome_druid_set_buttons_sensitive (druid, TRUE, FALSE, TRUE, FALSE);
gnome_druid_set_show_finish (druid, TRUE);
}
else
{
//gtk_file_chooser_get_filename ()
//gnomegadu_import_userlist_from_file();
}
return FALSE;
}
/**
* gnome_druid_append_page:
* @druid: A #GnomeDruid widget.
* @page: The #GnomeDruidPage to be appended.
*
* Description: This will append @page onto the end of the internal list.
* Since #GnomeDruid is just a container, you will need to also call
* gtk_widget_show() on the page, otherwise the page will not be shown.
**/
void
gnome_druid_append_page (GnomeDruid *druid,
GnomeDruidPage *page)
{
GList *list;
g_return_if_fail (druid != NULL);
g_return_if_fail (GNOME_IS_DRUID (druid));
g_return_if_fail (page != NULL);
g_return_if_fail (GNOME_IS_DRUID_PAGE (page));
list = g_list_last (druid->_priv->children);
if (list) {
gnome_druid_insert_page (druid, GNOME_DRUID_PAGE (list->data), page);
} else {
gnome_druid_insert_page (druid, NULL, page);
}
}
gboolean
on_userlist_import_page_last_back (GnomeDruidPage * druidpage, GtkWidget * widget, gpointer user_data)
{
GtkWidget *radio_import_server, *radio_import_file;
GnomeDruid *druid = GNOME_DRUID (glade_xml_get_widget (gladexml_import_userlist, "ImportUserlistDruid"));
GnomeDruidPage *page1 = GNOME_DRUID_PAGE (glade_xml_get_widget (gladexml_import_userlist, "userlist_import_page_1"));
radio_import_server = glade_xml_get_widget (gladexml_import_userlist, "RadioImportServer");
radio_import_file = glade_xml_get_widget (gladexml_import_userlist, "RadioImportFile");
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (radio_import_server)))
{
gnome_druid_set_page (druid, page1);
return TRUE;
}
return FALSE;
}
static void
gnome_druid_back_callback (GtkWidget *button, GnomeDruid *druid)
{
GList *list;
g_return_if_fail (druid->_priv->current != NULL);
if (gnome_druid_page_back (druid->_priv->current))
return;
/* Make sure that we have a next list item */
list = g_list_find (druid->_priv->children, druid->_priv->current);
g_return_if_fail (list->prev != NULL);
list = list->prev;
while (list != NULL &&
! GTK_WIDGET_VISIBLE (list->data))
list = list->prev;
if ( ! list)
return;
gnome_druid_set_page (druid, GNOME_DRUID_PAGE (list->data));
}
/*--------------------------------------------------------------------------*/
static void
add_start_page( GnomeDruid *wdruid, GdkPixbuf *logo )
{
GtkWidget *wpage;
GdkColor druid_bg_color = DRUID_BG_COLOR;
GdkColor druid_title_color = DRUID_TITLE_COLOR;
gbDate date_min, date_max, date_today;
gchar *date_min_string, *date_max_string, *date_today_string;
gchar *msg, *msg1;
gbTableModel *table_model;
gb_debug (DEBUG_UPDATE, "START");
table_model = gb_table_get_model ();
date_min = gb_table_model_get_rdate_min (table_model);
date_max = gb_table_model_get_rdate_max (table_model);
date_today = gb_table_model_get_rdate_today ();
date_min_string = gb_date_fmt( date_min );
date_max_string = gb_date_fmt( date_max );
date_today_string = gb_date_fmt( date_today );
if ( date_today == date_max ) {
msg1 = g_strdup_printf(
_( "Current redemption data will expire at the end\n"
"of this month (%s)\n" ), date_today_string );
}
else {
if ( date_today > date_max ) {
msg1 = g_strdup( _( "Current redemption data has expired.\n" ) );
}
else {
msg1 = g_strdup( "" );
}
}
msg = g_strdup_printf(
_( "%s\n"
"GBonds is currently configured with redemption data\n"
"for %s - %s.\n\n"
"New redemption data is published by the U.S. Treasury\n"
"every six months. This dialog will help you\n"
"download and install new redemption data.\n\n"
"You can hit cancel at any point to cancel this dialog."
),
msg1, date_min_string, date_max_string );
wpage = gnome_druid_page_edge_new_with_vals (GNOME_EDGE_START,
TRUE,
_("Update redemption tables"),
msg,
logo,
NULL,
NULL);
gnome_druid_page_edge_set_bg_color (GNOME_DRUID_PAGE_EDGE(wpage),
&druid_bg_color);
gnome_druid_page_edge_set_logo_bg_color (GNOME_DRUID_PAGE_EDGE(wpage),
&druid_bg_color);
gnome_druid_page_edge_set_title_color (GNOME_DRUID_PAGE_EDGE(wpage),
&druid_title_color);
gnome_druid_append_page( wdruid, GNOME_DRUID_PAGE(wpage) );
g_free( date_min_string );
g_free( date_max_string );
g_free( date_today_string );
g_free( msg );
g_free( msg1 );
gb_debug (DEBUG_UPDATE, "END");
}
static void
gnome_druid_size_request (GtkWidget *widget,
GtkRequisition *requisition)
{
guint16 temp_width, temp_height;
GList *list;
GnomeDruid *druid;
GtkRequisition child_requisition;
GnomeDruidPage *child;
int border;
g_return_if_fail (widget != NULL);
g_return_if_fail (GNOME_IS_DRUID (widget));
druid = GNOME_DRUID (widget);
temp_height = temp_width = 0;
border = GTK_CONTAINER(widget)->border_width;
/* We find the maximum size of all children widgets */
for (list = druid->_priv->children; list; list = list->next) {
child = GNOME_DRUID_PAGE (list->data);
if (GTK_WIDGET_VISIBLE (child)) {
gtk_widget_size_request (GTK_WIDGET (child), &child_requisition);
temp_width = MAX (temp_width, child_requisition.width);
temp_height = MAX (temp_height, child_requisition.height);
if (GTK_WIDGET_MAPPED (child) && child != druid->_priv->current)
gtk_widget_unmap (GTK_WIDGET(child));
}
}
requisition->width = temp_width + 2 * border;
requisition->height = temp_height + 2 * border;
#if 0
/* In an Attempt to show how the widgets are packed,
* here's a little diagram.
*
* [ Help ] ------------- [ Back ] [ Next ] [ Cancel ]
* /
* This part needs to be at least 1 button width.
* In addition, there is 1/4 X Button width between Cancel and Next,
* and a GNOME_PAD_SMALL between Next and Back.
*/
/* our_button width is temp_width and temp_height */
temp_height = 0;
temp_width = 0;
gtk_widget_size_request (druid->back, &child_requisition);
temp_width = MAX (temp_width, child_requisition.width);
temp_height = MAX (temp_height, child_requisition.height);
gtk_widget_size_request (druid->next, &child_requisition);
temp_width = MAX (temp_width, child_requisition.width);
temp_height = MAX (temp_height, child_requisition.height);
gtk_widget_size_request (druid->cancel, &child_requisition);
temp_width = MAX (temp_width, child_requisition.width);
temp_height = MAX (temp_height, child_requisition.height);
gtk_widget_size_request (druid->finish, &child_requisition);
temp_width = MAX (temp_width, child_requisition.width);
temp_height = MAX (temp_height, child_requisition.height);
gtk_widget_size_request (druid->help, &child_requisition);
temp_width = MAX (temp_width, child_requisition.width);
temp_height = MAX (temp_height, child_requisition.height);
temp_width += border * 2;
temp_height += GNOME_PAD_SMALL;
temp_width = temp_width * 21/4 + GNOME_PAD_SMALL * 3;
#endif
gtk_widget_size_request (druid->_priv->bbox, &child_requisition);
/* pick which is bigger, the buttons, or the GnomeDruidPages */
requisition->width = MAX (child_requisition.width, requisition->width);
requisition->height += child_requisition.height + GNOME_PAD_SMALL * 2;
}
static void
ap_druid_create (AcctPeriodInfo *info)
{
GladeXML *xml;
GtkWidget *w;
xml = gnc_glade_xml_new ("acctperiod.glade", "Acct Period Druid");
info->window = glade_xml_get_widget (xml, "Acct Period Druid");
info->druid = GNOME_DRUID (glade_xml_get_widget (xml, "acct_period_druid"));
gnc_druid_set_colors (info->druid);
info->start_page =
GNOME_DRUID_PAGE(glade_xml_get_widget (xml, "start page"));
info->menu_page =
GNOME_DRUID_PAGE(glade_xml_get_widget (xml, "menu page"));
info->book_page =
GNOME_DRUID_PAGE(glade_xml_get_widget (xml, "book page"));
info->finish_page =
GNOME_DRUID_PAGE(glade_xml_get_widget (xml, "finish page"));
info->close_status = -1;
/* Find the date of the earliest transaction in the book.
* Add a year minus a day as the first guess for book closing,
* and use that to set up the freq spec widget. */
info->earliest = get_earliest_in_book (gnc_get_current_book());
info->earliest_str = qof_print_date(info->earliest);
PINFO ("date of earliest transaction is %ld %s",
info->earliest, ctime (&info->earliest));
g_date_clear (&info->closing_date, 1);
g_date_set_time_t (&info->closing_date, info->earliest);
g_date_clear (&info->prev_closing_date, 1);
info->prev_closing_date = info->closing_date;
g_date_add_years (&info->closing_date, 1);
{
Recurrence *r = g_new0(Recurrence, 1);
recurrenceSet(r, 1, PERIOD_MONTH, &info->closing_date, WEEKEND_ADJ_NONE);
info->period = NULL;
info->period = g_list_append(info->period, r);
}
info->period_menu = GNC_FREQUENCY(
gnc_frequency_new_from_recurrence(info->period, &info->closing_date));
/* Change the text so that its more mainingful for this druid */
gnc_frequency_set_frequency_label_text(info->period_menu, _("Period:"));
gnc_frequency_set_date_label_text(info->period_menu, _("Closing Date:"));
/* Reparent to the correct location */
w = glade_xml_get_widget (xml, "period box");
gtk_box_pack_start (GTK_BOX (w), GTK_WIDGET (info->period_menu),
TRUE, TRUE, 0);
/* Get handles to all of the other widgets we'll need */
info->period_remarks =
GTK_LABEL (glade_xml_get_widget (xml, "remarks label"));
info->close_results =
GTK_LABEL (glade_xml_get_widget (xml, "results label"));
info->book_details =
GTK_LABEL (glade_xml_get_widget (xml, "book label"));
info->book_title =
GTK_ENTRY (glade_xml_get_widget (xml, "book title entry"));
info->book_notes =
GTK_TEXT_VIEW (glade_xml_get_widget (xml, "book notes text"));
/* generic finished/close/abort signals */
g_signal_connect (info->window, "destroy",
G_CALLBACK (ap_window_destroy_cb), info);
g_signal_connect (info->druid, "cancel",
G_CALLBACK (ap_druid_cancel), info);
g_signal_connect (info->menu_page, "prepare",
G_CALLBACK (ap_show_menu), info);
g_signal_connect (info->menu_page, "next",
G_CALLBACK (ap_validate_menu), info);
g_signal_connect (info->book_page, "prepare",
G_CALLBACK (ap_show_book), info);
g_signal_connect (info->book_page, "next",
G_CALLBACK (ap_close_period), info);
g_signal_connect (info->finish_page, "prepare",
G_CALLBACK (ap_show_done), info);
g_signal_connect (info->finish_page, "finish",
G_CALLBACK (ap_finish), info);
/* User changes the accouting period or date signals */
g_signal_connect (info->period_menu, "changed",
G_CALLBACK (ap_changed), info);
}
at_job_t *make_new_at_job() {
GtkWidget *druid, *page_start, *page_at1, *page_at2, *page_finish;
GtkWidget *hbox, *frame, *align, *bigvbox;
at_druid_info *info;
struct tm *tp;
time_t t;
char *fname;
GdkPixbuf *logo = NULL;
fname = gnome_pixmap_file("gnome-clock.png");
if (fname)
logo = gdk_pixbuf_new_from_file(fname, NULL);
g_free(fname);
time(&t);
tp = localtime(&t);
info = g_new(at_druid_info, 1);
druid = gnome_druid_new_with_window("New One-Time Job",
NULL, TRUE, &info->win);
page_start = gnome_druid_page_edge_new_with_vals(
GNOME_EDGE_START, FALSE,
"Create new one-time job",
"This series of dialogs will step\n"
"you through the process of creating\n"
"a new one-time job.", logo, NULL, NULL);
page_at1 = gnome_druid_page_standard_new_with_vals(
"Choose a time and date", logo, NULL);
page_at2 = gnome_druid_page_standard_new_with_vals(
"Select command", logo, NULL);
page_finish = gnome_druid_page_edge_new_with_vals(
GNOME_EDGE_FINISH, FALSE,
"Confirm new job", NULL, logo, NULL, NULL);
bigvbox = gtk_vbox_new(FALSE, 0);
align = gtk_alignment_new(0.5, 0.5, 0.0, 0.0);
gtk_container_add(GTK_CONTAINER(align), bigvbox);
gtk_box_pack_start(GTK_BOX(GNOME_DRUID_PAGE_STANDARD(page_at1)->vbox),
align, TRUE, TRUE, 0);
info->cal = gtk_calendar_new();
gtk_box_pack_start(GTK_BOX(bigvbox), info->cal, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
frame = gtk_frame_new("Time");
gtk_container_set_border_width(GTK_CONTAINER(frame), 8);
gtk_box_pack_start(GTK_BOX(bigvbox), frame, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), hbox);
info->hour = make_new_spinner("Hour:", tp->tm_hour, 0, 23, 5, hbox);
info->minute = make_new_spinner("Minute:", tp->tm_min, 0, 59, 5, hbox);
info->command = make_job_page(GNOME_DRUID_PAGE_STANDARD(page_at2)->vbox);
gtk_signal_connect_object(GTK_OBJECT(page_finish), "finish",
GTK_SIGNAL_FUNC(at_commit_job), (gpointer)info);
gtk_signal_connect_object(GTK_OBJECT(info->win), "destroy",
GTK_SIGNAL_FUNC(g_free), (gpointer)info);
gtk_signal_connect(GTK_OBJECT(page_finish), "prepare",
GTK_SIGNAL_FUNC(prepare_last_page), (gpointer)info);
gtk_signal_connect(GTK_OBJECT(info->command), "changed",
GTK_SIGNAL_FUNC(cmd_changed), (gpointer)druid);
gnome_druid_append_page(GNOME_DRUID(druid), GNOME_DRUID_PAGE(page_start));
gnome_druid_append_page(GNOME_DRUID(druid), GNOME_DRUID_PAGE(page_at1));
gnome_druid_append_page(GNOME_DRUID(druid), GNOME_DRUID_PAGE(page_at2));
gnome_druid_append_page(GNOME_DRUID(druid), GNOME_DRUID_PAGE(page_finish));
gnome_druid_set_page(GNOME_DRUID(druid), GNOME_DRUID_PAGE(page_start));
gtk_window_set_modal(GTK_WINDOW(info->win), TRUE);
gtk_widget_show_all(info->win);
g_object_unref(logo);
return NULL;
}
/*--------------------------------------------------------------------------*/
static void
add_downloading_page( GnomeDruid *wdruid, GdkPixbuf *logo )
{
GtkWidget *wpage, *wvbox, *wvbox2, *wvbox3, *wvbox4;
GtkWidget *whbox2, *whbox3, *whbox4;
GtkWidget *wlabel1, *wlabel2, *wframe;
GdkColor druid_bg_color = DRUID_BG_COLOR;
GdkColor druid_title_color = DRUID_TITLE_COLOR;
gb_debug (DEBUG_UPDATE, "START");
wpage = gnome_druid_page_standard_new_with_vals (_("Downloading..."),
logo,
NULL);
gnome_druid_page_standard_set_background(GNOME_DRUID_PAGE_STANDARD(wpage),
&druid_bg_color);
gnome_druid_page_standard_set_logo_background(GNOME_DRUID_PAGE_STANDARD(wpage),
&druid_bg_color);
gnome_druid_page_standard_set_title_foreground(GNOME_DRUID_PAGE_STANDARD(wpage),
&druid_title_color);
gnome_druid_append_page( wdruid, GNOME_DRUID_PAGE(wpage) );
wvbox = GNOME_DRUID_PAGE_STANDARD(wpage)->vbox;
wvbox2 = gtk_vbox_new( FALSE, 10 );
gtk_container_set_border_width( GTK_CONTAINER(wvbox2), 20 );
gtk_box_pack_start( GTK_BOX(wvbox), wvbox2, TRUE, FALSE, 0 );
wlabel1 = gtk_label_new( _("Please wait while GBonds downloads new redemption data.") );
gtk_box_pack_start( GTK_BOX(wvbox2), wlabel1, FALSE, TRUE, 0 );
wframe = gtk_frame_new( NULL );
gtk_box_pack_start( GTK_BOX(wvbox2), wframe, FALSE, TRUE, 0 );
whbox2 = gtk_hbox_new( FALSE, 0 );
gtk_container_set_border_width( GTK_CONTAINER(whbox2), 5 );
gtk_container_add( GTK_CONTAINER(wframe), whbox2 );
status_label = gtk_label_new( _("Status") );
gtk_label_set_justify( GTK_LABEL(status_label), GTK_JUSTIFY_LEFT );
gtk_box_pack_start( GTK_BOX(whbox2), status_label, FALSE, TRUE, 0 );
wvbox3 = gtk_vbox_new( FALSE, 2 );
gtk_box_pack_start( GTK_BOX(wvbox2), wvbox3, TRUE, FALSE, 0 );
whbox3 = gtk_hbox_new( FALSE, 0 );
gtk_box_pack_start( GTK_BOX(wvbox3), whbox3, FALSE, TRUE, 0 );
file_label = gtk_label_new( _("File") );
gtk_label_set_justify( GTK_LABEL(file_label), GTK_JUSTIFY_LEFT );
gtk_box_pack_start( GTK_BOX(whbox3), file_label, FALSE, TRUE, 0 );
file_progress = gtk_progress_bar_new();
gtk_progress_bar_set_text( GTK_PROGRESS_BAR(file_progress), "" );
gtk_box_pack_start( GTK_BOX(wvbox3), file_progress, FALSE, TRUE, 0 );
wvbox4 = gtk_vbox_new( FALSE, 2 );
gtk_box_pack_start( GTK_BOX(wvbox2), wvbox4, TRUE, FALSE, 0 );
whbox4 = gtk_hbox_new( FALSE, 0 );
gtk_box_pack_start( GTK_BOX(wvbox4), whbox4, FALSE, TRUE, 0 );
wlabel2 = gtk_label_new( _("Total") );
gtk_label_set_justify( GTK_LABEL(wlabel2), GTK_JUSTIFY_LEFT );
gtk_box_pack_start( GTK_BOX(whbox4), wlabel2, FALSE, TRUE, 0 );
total_progress = gtk_progress_bar_new();
gtk_progress_bar_set_text( GTK_PROGRESS_BAR(total_progress), "" );
gtk_box_pack_start( GTK_BOX(wvbox4), total_progress, FALSE, TRUE, 0 );
g_signal_connect_after( G_OBJECT(wpage), "prepare",
G_CALLBACK(prepare_downloading_page), NULL );
gb_debug (DEBUG_UPDATE, "END");
}
/*--------------------------------------------------------------------------*/
static void
download_done( DownloadCallbackData *data )
{
GList *p;
GnomeVFSFileInfo *info, tmp_info = {0};
gchar *hash_name;
gchar *hash_path, *hash_text_uri;
gchar *file_path, *file_text_uri;
gchar *date_min, *date_max, *finish_msg;
gchar *data_dir;
gbTableModel *table_model;
gb_debug (DEBUG_UPDATE, "START");
/* Rename downloaded files (undo name hash) */
data_dir = gb_util_get_home_data_dir();
for ( p=data->list; p != NULL; p=p->next ) {
info = (GnomeVFSFileInfo *)p->data;
hash_name = hash_filename( info->name );
hash_path = g_build_filename( data_dir, hash_name, NULL );
hash_text_uri = gnome_vfs_get_uri_from_local_path( hash_path );
file_path = g_build_filename( data_dir, info->name, NULL );
file_text_uri = gnome_vfs_get_uri_from_local_path( file_path );
gnome_vfs_get_file_info (hash_text_uri, &tmp_info, GNOME_VFS_FILE_INFO_DEFAULT);
if ( info->size == tmp_info.size ) {
gnome_vfs_move( hash_text_uri, file_text_uri, FALSE );
} else {
g_warning ("%s: Temporary file size (%"
GNOME_VFS_OFFSET_FORMAT_STR
") does not match remote size (%"
GNOME_VFS_OFFSET_FORMAT_STR
").",
info->name, tmp_info.size, info->size);
gnome_vfs_unlink (hash_text_uri);
}
g_free( hash_name );
g_free( hash_path );
g_free( hash_text_uri );
g_free( file_path );
g_free( file_text_uri );
}
g_free( data_dir );
/* Now reread redemption tables */
table_model = gb_table_get_model ();
gb_table_model_update (table_model);
/* customize finish page for this outcome */
gnome_druid_page_edge_set_title( GNOME_DRUID_PAGE_EDGE(finish_page),
_( "Download done" ) );
date_min = gb_date_fmt (gb_table_model_get_rdate_min (table_model));
date_max = gb_date_fmt (gb_table_model_get_rdate_max (table_model));
finish_msg = g_strdup_printf(
_( "GBonds has successfully downloaded "
"%d new redemption files.\n\n"
"GBonds is now configured with redemption data\n"
"for %s - %s.\n" ),
data->n, date_min, date_max );
gnome_druid_page_edge_set_text( GNOME_DRUID_PAGE_EDGE(finish_page), finish_msg );
g_free( date_min );
g_free( date_max );
g_free( finish_msg );
remote_dir_handle = NULL;
/* Now jump to the finish page */
gnome_druid_set_page( GNOME_DRUID(update_druid),
GNOME_DRUID_PAGE(finish_page) );
gb_debug (DEBUG_UPDATE, "END");
}
