dialog-invoice.c

/*
 * dialog-invoice.c -- Dialog for Invoice entry
 * Copyright (C) 2001,2002,2006 Derek Atkins
 * Author: Derek Atkins <warlord@MIT.EDU>
 *
 * Copyright (c) 2005,2006 David Hampton <hampton@employees.org>
 *
 * 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, contact:
 *
 * Free Software Foundation           Voice:  +1-617-542-5942
 * 51 Franklin Street, Fifth Floor    Fax:    +1-617-542-2652
 * Boston, MA  02110-1301,  USA       gnu@gnu.org
 */

#include "config.h"

#include <gnome.h>
#include <glib/gi18n.h>
#include <libguile.h>
#include "swig-runtime.h"

#include "gncObject.h"
#include "QueryCore.h"
#include "QueryNew.h"

#include "dialog-utils.h"
#include "gnc-component-manager.h"
#include "gnc-ui.h"
#include "gnc-gconf-utils.h"
#include "gnc-gui-query.h"
#include "gnc-ui-util.h"
#include "qof.h"
#include "gnc-date-edit.h"
#include "gnc-amount-edit.h"
#include "gnucash-sheet.h"
#include "window-report.h"
#include "dialog-search.h"
#include "search-param.h"
#include "gnc-session.h"
#include "gncInvoice.h"
#include "gncInvoiceP.h"

#include "gncEntryLedger.h"

#include "gnc-plugin-page.h"
#include "gnc-general-search.h"
#include "dialog-date-close.h"
#include "dialog-invoice.h"
#include "dialog-job.h"
#include "business-gnome-utils.h"
#include "dialog-payment.h"
#include "dialog-tax-table.h"
#include "dialog-billterms.h"
#include "dialog-account.h"
#include "guile-mappings.h"

#include "dialog-query-list.h"

#include "gnc-plugin-business.h"
#include "gnc-plugin-page-invoice.h"
#include "gnc-main-window.h"

/* Disable -Waddress.  GCC 4.2 warns (and fails to compile with -Werror) when
 * passing the address of a guid on the stack to QOF_BOOK_LOOKUP_ENTITY via
 * gncInvoiceLookup and friends.  When the macro gets inlined, the compiler
 * emits a warning that the guid null pointer test is always true.
 */
#if (__GNUC__ >= 4 && __GNUC_MINOR__ >= 2)
#    pragma GCC diagnostic ignored "-Waddress"
#endif

#define DIALOG_NEW_INVOICE_CM_CLASS "dialog-new-invoice"
#define DIALOG_VIEW_INVOICE_CM_CLASS "dialog-view-invoice"

#define GCONF_SECTION_SEARCH  "dialogs/business/invoice_search"

#define LAST_POSTED_TO_ACCT "last-posted-to-acct"

void gnc_invoice_window_ok_cb (GtkWidget *widget, gpointer data);
void gnc_invoice_window_cancel_cb (GtkWidget *widget, gpointer data);
void gnc_invoice_window_help_cb (GtkWidget *widget, gpointer data);
void gnc_invoice_id_changed_cb (GtkWidget *widget, gpointer data);

#define ENUM_INVOICE_TYPE(_) \
  _(NEW_INVOICE, )  \
  _(MOD_INVOICE, )  \
  _(EDIT_INVOICE, ) \
  _(VIEW_INVOICE, )

DEFINE_ENUM(InvoiceDialogType, ENUM_INVOICE_TYPE)
AS_STRING_DEC(InvoiceDialogType, ENUM_INVOICE_TYPE)
FROM_STRING_DEC(InvoiceDialogType, ENUM_INVOICE_TYPE)

FROM_STRING_FUNC(InvoiceDialogType, ENUM_INVOICE_TYPE)
AS_STRING_FUNC(InvoiceDialogType, ENUM_INVOICE_TYPE)

struct _invoice_select_window {
  GNCBook *     book;
  GncOwner *    owner;
  QueryNew *    q;
  GncOwner      owner_def;
};


struct _invoice_window {
  GladeXML *    xml;

  GtkWidget *   dialog;         /* Used by 'New Invoice Window' */
  GncPluginPage *page;          /* Used by 'Edit Invoice' Page */

  /* Summary Bar Widgets */
  GtkWidget *   total_label;
  GtkWidget *   total_cash_label;
  GtkWidget *   total_charge_label;
  GtkWidget *   total_subtotal_label;
  GtkWidget *   total_tax_label;

  /* Data Widgets */
  GtkWidget *   id_entry;
  GtkWidget *   notes_text;
  GtkWidget *   opened_date;
  GtkWidget *   posted_date_hbox;
  GtkWidget *   posted_date;
  GtkWidget *   active_check;

  GtkWidget *   owner_box;
  GtkWidget *   owner_label;
  GtkWidget *   owner_choice;
  GtkWidget *   job_label;
  GtkWidget *   job_box;
  GtkWidget *   job_choice;
  GtkWidget *   billing_id_entry;
  GtkWidget *   terms_menu;

  /* Project Widgets (used for Bills only) */
  GtkWidget *   proj_frame;
  GtkWidget *   proj_cust_box;
  GtkWidget *   proj_cust_choice;
  GtkWidget *   proj_job_box;
  GtkWidget *   proj_job_choice;

  /* Exp Voucher Widgets */
  GtkWidget *   to_charge_frame;
  GtkWidget *   to_charge_edit;

  gint          width;

  GncBillTerm * terms;
  GnucashRegister *     reg;
  GncEntryLedger *      ledger;

  invoice_sort_type_t   last_sort;

  InvoiceDialogType     dialog_type;
  GUID          invoice_guid;
  gint          component_id;
  GNCBook *     book;
  GncInvoice *  created_invoice;
  GncOwner      owner;
  GncOwner      job;

  GncOwner      proj_cust;
  GncOwner      proj_job;

  /* for Unposting */
  gboolean      reset_tax_tables;
};

/* Forward definitions for CB functions */
void gnc_invoice_window_closeCB (GtkWidget *widget, gpointer data);
void gnc_invoice_window_active_toggled_cb (GtkWidget *widget, gpointer data);
gboolean gnc_invoice_window_leave_notes_cb (GtkWidget *widget, GdkEventFocus *event, gpointer data);

#define INV_WIDTH_PREFIX "invoice_reg"
#define BILL_WIDTH_PREFIX "bill_reg"
#define VOUCHER_WIDTH_PREFIX "voucher_reg"

static void gnc_invoice_update_window (InvoiceWindow *iw, GtkWidget *widget);
static InvoiceWindow * gnc_ui_invoice_modify (GncInvoice *invoice);

/*******************************************************************************/
/* FUNCTIONS FOR ACCESSING DATA STRUCTURE FIELDS */

static GtkWidget *
iw_get_window (InvoiceWindow *iw)
{
  if (iw->page)
    return gnc_plugin_page_get_window(iw->page);
  return iw->dialog;
}

GtkWidget *
gnc_invoice_get_register(InvoiceWindow *iw)
{
  if (iw)
    return (GtkWidget *)iw->reg;
  return NULL;
}

/*******************************************************************************/
/* FUNCTIONS FOR UNPOSTING */

static gboolean
iw_ask_unpost (InvoiceWindow *iw)
{
  GtkWidget *dialog, *toggle, *pixmap;
  GladeXML *xml;
  gint response;
  char *s;

  xml = gnc_glade_xml_new ("invoice.glade", "Unpost Message Dialog");
  dialog = glade_xml_get_widget (xml, "Unpost Message Dialog");
  toggle = glade_xml_get_widget (xml, "yes_tt_reset");
  pixmap = glade_xml_get_widget (xml, "q_pixmap");

  gtk_window_set_transient_for (GTK_WINDOW(dialog),
                                GTK_WINDOW(iw_get_window(iw)));

  iw->reset_tax_tables = FALSE;

  s = gnome_program_locate_file (NULL,
                                 GNOME_FILE_DOMAIN_PIXMAP,
                                 "gnome-question.png", TRUE, NULL);
  if (s) {
    pixmap = gtk_image_new_from_file(s);
    g_free(s);
  }

  gtk_widget_show_all(dialog);

  response = gtk_dialog_run(GTK_DIALOG(dialog));
  if (response == GTK_RESPONSE_OK)
    iw->reset_tax_tables =
      gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggle));

  gtk_widget_destroy(dialog);
  return (response == GTK_RESPONSE_OK);
}

/*******************************************************************************/
/* INVOICE WINDOW */

static GncInvoice *
iw_get_invoice (InvoiceWindow *iw)
{
  if (!iw)
    return NULL;

  return gncInvoiceLookup (iw->book, &iw->invoice_guid);
}

static void gnc_ui_to_invoice (InvoiceWindow *iw, GncInvoice *invoice)
{
  GtkTextBuffer* text_buffer;
  GtkTextIter start, end;
  gchar *text;
  Timespec ts;

  if (iw->dialog_type == VIEW_INVOICE)
    return;

  gnc_suspend_gui_refresh ();

  gncInvoiceBeginEdit (invoice);

  if (iw->active_check)
    gncInvoiceSetActive (invoice, gtk_toggle_button_get_active
                         (GTK_TOGGLE_BUTTON (iw->active_check)));

  text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(iw->notes_text));
  gtk_text_buffer_get_bounds (text_buffer, &start, &end);
  text = gtk_text_buffer_get_text (text_buffer, &start, &end, FALSE);
  gncInvoiceSetNotes (invoice, text);

  if (iw->to_charge_edit)
    gncInvoiceSetToChargeAmount (invoice,
                                 gnc_amount_edit_get_amount
                                 (GNC_AMOUNT_EDIT (iw->to_charge_edit)));

  /* Only set these values for NEW/MOD INVOICE types */
  if (iw->dialog_type != EDIT_INVOICE) {
    gncInvoiceSetID (invoice, gtk_editable_get_chars
                     (GTK_EDITABLE (iw->id_entry), 0, -1));
    gncInvoiceSetBillingID (invoice, gtk_editable_get_chars
                            (GTK_EDITABLE (iw->billing_id_entry), 0, -1));
    gncInvoiceSetTerms (invoice, iw->terms);

    ts = gnc_date_edit_get_date_ts (GNC_DATE_EDIT (iw->opened_date));
    gncInvoiceSetDateOpened (invoice, ts);

    gnc_owner_get_owner (iw->owner_choice, &(iw->owner));
    if (iw->job_choice)
      gnc_owner_get_owner (iw->job_choice, &(iw->job));

    /* Only set the job if we've actually got one */
    if (gncOwnerGetJob (&(iw->job)))
      gncInvoiceSetOwner (invoice, &(iw->job));
    else
      gncInvoiceSetOwner (invoice, &(iw->owner));

    /* Set the invoice currency based on the owner */
    gncInvoiceSetCurrency (invoice, gncOwnerGetCurrency (&iw->owner));

    /* Only set the BillTo if we've actually got one */
    if (gncOwnerGetJob (&iw->proj_job))
      gncInvoiceSetBillTo (invoice, &iw->proj_job);
    else
      gncInvoiceSetBillTo (invoice, &iw->proj_cust);
  }

  gncInvoiceCommitEdit (invoice);
  gnc_resume_gui_refresh ();
}

static gboolean
gnc_invoice_window_verify_ok (InvoiceWindow *iw)
{
  const char *res;
  gchar *string;

  /* save the current entry in the ledger? */
  if (!gnc_entry_ledger_check_close (iw_get_window(iw), iw->ledger))
    return FALSE;

  /* Check the Owner */
  gnc_owner_get_owner (iw->owner_choice, &(iw->owner));
  res = gncOwnerGetName (&(iw->owner));
  if (res == NULL || safe_strcmp (res, "") == 0) {
    gnc_error_dialog (iw_get_window(iw),
                      /* Translators: In this context,
                       * 'Billing information' maps to the
                       * label in the frame and means
                       * e.g. customer i.e. the company being
                       * invoiced. */
                      _("You need to supply Billing Information."));
    return FALSE;
  }

  /* Check the ID; set one if necessary */
  res = gtk_entry_get_text (GTK_ENTRY (iw->id_entry));
  if (safe_strcmp (res, "") == 0) {
    /* Invoices and bills have separate counters.
       Therefore we pass the GncOwer to gncInvoiceNextID
       so it knows whether we are creating a bill
       or an invoice. */
    string = g_strdup_printf ("%.6" G_GINT64_FORMAT,
                              gncInvoiceNextID(iw->book, &(iw->owner)));
    gtk_entry_set_text (GTK_ENTRY (iw->id_entry), string);
    g_free(string);
  }
      
  return TRUE;
}

static gboolean
gnc_invoice_window_ok_save (InvoiceWindow *iw)
{
  if (!gnc_invoice_window_verify_ok (iw))
    return FALSE;

  {
    GncInvoice *invoice = iw_get_invoice (iw);
    if (invoice) {
      gnc_ui_to_invoice (iw, invoice);
    }
    /* Save the invoice to return it later. */
    iw->created_invoice = invoice;
  }
  return TRUE;
}

void
gnc_invoice_window_ok_cb (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;

  if (!gnc_invoice_window_ok_save (iw))
    return;

  /* Ok, we don't need this anymore */
  iw->invoice_guid = *xaccGUIDNULL ();

  /* if this is a NEW_INVOICE, and created_invoice is NON-NULL, the
   * open up a new window with the invoice.  This used to be done
   * in gnc_ui_invoice_new() but cannot be done anymore
   */
  if (iw->dialog_type == NEW_INVOICE && iw->created_invoice)
    gnc_ui_invoice_edit (iw->created_invoice);

  gnc_close_gui_component (iw->component_id);
}

void
gnc_invoice_window_cancel_cb (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;

  gnc_close_gui_component (iw->component_id);
}

void
gnc_invoice_window_help_cb (GtkWidget *widget, gpointer data)
{
  gnc_gnome_help(HF_HELP, HL_USAGE);
}

void
gnc_invoice_window_destroy_cb (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;
  GncInvoice *invoice = iw_get_invoice (iw);

  gnc_suspend_gui_refresh ();

  if (iw->dialog_type == NEW_INVOICE && invoice != NULL) {
    gncInvoiceBeginEdit (invoice);
    gncInvoiceDestroy (invoice);
    iw->invoice_guid = *xaccGUIDNULL ();
  }

  gnc_entry_ledger_destroy (iw->ledger);
  gnc_unregister_gui_component (iw->component_id);
  gtk_widget_destroy(widget);
  gnc_resume_gui_refresh ();

  g_free (iw);
}

void
gnc_invoice_window_closeCB (GtkWidget *widget, gpointer data)
{
  gnc_invoice_window_ok_cb (widget, data);
}

void
gnc_invoice_window_editCB (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;
  GncInvoice *invoice = iw_get_invoice (iw);

  if (invoice)
    gnc_ui_invoice_modify (invoice);
}

void
gnc_invoice_window_recordCB (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;

  if (!iw || !iw->ledger)
    return;

  if (!gnc_entry_ledger_commit_entry (iw->ledger))
    return;

  gnucash_register_goto_next_virt_row (iw->reg);
}

void
gnc_invoice_window_cancelCB (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;

  if (!iw || !iw->ledger)
    return;

  gnc_entry_ledger_cancel_cursor_changes (iw->ledger);
}

void
gnc_invoice_window_deleteCB (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;
  GncEntry *entry;

  if (!iw || !iw->ledger)
    return;

  /* get the current entry based on cursor position */
  entry = gnc_entry_ledger_get_current_entry (iw->ledger);
  if (!entry) {
    gnc_entry_ledger_cancel_cursor_changes (iw->ledger);
    return;
  }

  /* deleting the blank entry just cancels */
  if (entry == gnc_entry_ledger_get_blank_entry (iw->ledger)) {
    gnc_entry_ledger_cancel_cursor_changes (iw->ledger);
    return;
  }

  /* Verify that the user really wants to delete this entry */
  {
    const char *message = _("Are you sure you want to delete the "
                            "selected entry?");
    const char *order_warn = _("This entry is attached to an order and "
                               "will be deleted from that as well!");
    char *msg;
    gboolean result;

    if (gncEntryGetOrder (entry))
      msg = g_strconcat (message, "\n\n", order_warn, (char *)NULL);
    else
      msg = g_strdup (message);

    result = gnc_verify_dialog (iw_get_window(iw), FALSE, msg);
    g_free (msg);

    if (!result)
      return;
  }

  /* Yep, let's delete */
  gnc_entry_ledger_delete_current_entry (iw->ledger);
  return;
}

void
gnc_invoice_window_duplicateCB (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;

  if (!iw || !iw->ledger)
    return;

  gnc_entry_ledger_duplicate_current_entry (iw->ledger);
}

void
gnc_invoice_window_blankCB (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;

  if (!iw || !iw->ledger)
    return;

  if (!gnc_entry_ledger_commit_entry (iw->ledger))
    return;

  {
    VirtualCellLocation vcell_loc;
    GncEntry *blank;

    blank = gnc_entry_ledger_get_blank_entry (iw->ledger);
    if (blank == NULL)
      return;

    if (gnc_entry_ledger_get_entry_virt_loc (iw->ledger, blank, &vcell_loc))
      gnucash_register_goto_virt_cell (iw->reg, vcell_loc);
  }
}

void
gnc_invoice_window_printCB (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;
  GncInvoice *invoice = iw_get_invoice (iw);
  SCM func, arg;
  SCM args = SCM_EOL;
  int report_id;

  g_return_if_fail (invoice);

  func = scm_c_eval_string ("gnc:invoice-report-create");
  g_return_if_fail (SCM_PROCEDUREP (func));

  arg = SWIG_NewPointerObj(invoice, SWIG_TypeQuery("_p__gncInvoice"), 0);
  args = scm_cons (arg, args);

  /* scm_gc_protect_object(func); */

  arg = scm_apply (func, args, SCM_EOL);
  g_return_if_fail (SCM_EXACTP (arg));
  report_id = scm_num2int (arg, SCM_ARG1, __FUNCTION__);

  /* scm_gc_unprotect_object(func); */
  if (report_id >= 0)
    reportWindow (report_id);
}

void
gnc_invoice_window_postCB (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;
  GncInvoice *invoice;
  char *message, *memo, *ddue_label, *post_label, *acct_label, *question_label;
  Account *acc = NULL;
  GList * acct_types = NULL;
  Timespec ddue, postdate;
  gboolean accumulate;
  QofInstance *owner_inst;
  KvpFrame *kvpf;
  KvpValue *kvp_val;

  /* Make sure the invoice is ok */
  if (!gnc_invoice_window_verify_ok (iw))
      return;

  invoice = iw_get_invoice (iw);
  if (!invoice)
    return;

  /* Check that there is at least one Entry */
  invoice = iw_get_invoice (iw);
  if (gncInvoiceGetEntries (invoice) == NULL) {
    gnc_error_dialog (iw_get_window(iw),
                      _("The Invoice must have at least one Entry."));
    return;
  }

  /* Make sure that the invoice has a positive balance */
  if (gnc_numeric_negative_p(gncInvoiceGetTotal(invoice))) {
    gnc_error_dialog(iw_get_window(iw),
                     _("You may not post an invoice with a negative total value."));
    return;
  }

  if (iw->total_cash_label &&
      gnc_numeric_negative_p(gncInvoiceGetTotalOf(invoice, GNC_PAYMENT_CASH))) {
    gnc_error_dialog(iw_get_window(iw),
                     _("You may not post an expense voucher with a negative total cash value."));
    return;
  }

  /* Ok, we can post this invoice.  Ask for verification, set the due date,
   * post date, and posted account
   */
  message = _("Do you really want to post the invoice?");
  ddue_label = _("Due Date");
  post_label = _("Post Date");
  acct_label = _("Post to Account");
  question_label = _("Accumulate Splits?");

  /* Determine the type of account to post to */
  acct_types = gnc_business_account_types (&(iw->owner));

  /* Get the due date and posted account */
  timespecFromTime_t (&postdate, time(NULL));
  ddue = postdate;
  memo = NULL;

  owner_inst = qofOwnerGetOwner (gncOwnerGetEndOwner (&(iw->owner)));
  kvpf = qof_instance_get_slots (owner_inst);
  acc = xaccAccountLookup (kvp_frame_get_guid (kvpf, LAST_POSTED_TO_ACCT),
                           iw->book);

  /* Get the default for the accumulate option */
  accumulate = gnc_gconf_get_bool(GCONF_SECTION_INVOICE, "accumulate_splits", NULL);

  if (!gnc_dialog_dates_acct_question_parented (iw_get_window(iw), message, ddue_label,
                                       post_label, acct_label, question_label, TRUE,
                                       acct_types, iw->book, iw->terms,
                                       &ddue, &postdate, &memo, &acc, &accumulate))
    return;

  /* Yep, we're posting.  So, save the invoice... 
   * Note that we can safely ignore the return value; we checked
   * the verify_ok earlier, so we know it's ok.
   */
  gnc_suspend_gui_refresh ();
  gncInvoiceBeginEdit (invoice);
  gnc_invoice_window_ok_save (iw);

  /* Save acc as last used account in the kvp frame of the invoice owner */
  kvp_val = kvp_value_new_guid (qof_instance_get_guid (QOF_INSTANCE (acc)));;
  qof_begin_edit (owner_inst);
  kvp_frame_set_slot_nc (kvpf, LAST_POSTED_TO_ACCT, kvp_val);
  qof_instance_set_dirty (owner_inst);
  qof_commit_edit (owner_inst);
  
  /* ... post it; post date is set to now ... */
  gncInvoicePostToAccount (invoice, acc, &postdate, &ddue, memo, accumulate);
  gncInvoiceCommitEdit (invoice);
  gnc_resume_gui_refresh ();

  if (memo)
    g_free (memo);

  /* Reset the type; change to read-only! */
  iw->dialog_type = VIEW_INVOICE;
  gnc_entry_ledger_set_readonly (iw->ledger, TRUE);

  /* ... and redisplay here. */
  gnc_invoice_update_window (iw, NULL);
  gnc_table_refresh_gui (gnc_entry_ledger_get_table (iw->ledger), FALSE);
}

void
gnc_invoice_window_unpostCB (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;
  GncInvoice *invoice;
  gboolean result;

  invoice = iw_get_invoice (iw);
  if (!invoice)
    return;

  /* make sure the user REALLY wants to do this! */
  result = iw_ask_unpost(iw);
  if (!result) return;

  /* Attempt to unpost the invoice */
  gnc_suspend_gui_refresh ();
  result = gncInvoiceUnpost (invoice, iw->reset_tax_tables);
  gnc_resume_gui_refresh ();
  if (!result) return;

  /* if we get here, we succeeded in unposting -- reset the ledger and redisplay */
  iw->dialog_type = EDIT_INVOICE;
  gnc_entry_ledger_set_readonly (iw->ledger, FALSE);
  gnc_invoice_update_window (iw, NULL);
  gnc_table_refresh_gui (gnc_entry_ledger_get_table (iw->ledger), FALSE);
}

void gnc_invoice_window_cut_cb (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;
  gnucash_register_cut_clipboard (iw->reg);
}

void gnc_invoice_window_copy_cb (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;
  gnucash_register_copy_clipboard (iw->reg);
}

void gnc_invoice_window_paste_cb (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;
  gnucash_register_paste_clipboard (iw->reg);
}

void gnc_invoice_window_new_invoice_cb (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;
  if (gncOwnerGetJob (&iw->job)) {
    gnc_ui_invoice_new (&iw->job, iw->book);
  } else {
    gnc_ui_invoice_new (&iw->owner, iw->book);
  }
}

void gnc_business_call_owner_report (GncOwner *owner, Account *acc)
{
  int id;
  SCM args;
  SCM func;
  SCM arg;

  g_return_if_fail (owner);

  args = SCM_EOL;

  func = scm_c_eval_string ("gnc:owner-report-create");
  g_return_if_fail (SCM_PROCEDUREP (func));

  if (acc) {
    swig_type_info * qtype = SWIG_TypeQuery("_p_Account");
    g_return_if_fail (qtype);

    arg = SWIG_NewPointerObj(acc, qtype, 0);
    g_return_if_fail (arg != SCM_UNDEFINED);
    args = scm_cons (arg, args);
  } else {
    args = scm_cons (SCM_BOOL_F, args);
  }

  arg = SWIG_NewPointerObj(owner, SWIG_TypeQuery("_p__gncOwner"), 0);
  g_return_if_fail (arg != SCM_UNDEFINED);
  args = scm_cons (arg, args);

  /* Apply the function to the args */
  arg = scm_apply (func, args, SCM_EOL);
  g_return_if_fail (SCM_EXACTP (arg));
  id = scm_num2int (arg, SCM_ARG1, __FUNCTION__);

  if (id >= 0)
    reportWindow (id);
}

void gnc_invoice_window_report_owner_cb (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;
  gnc_business_call_owner_report (&iw->owner, NULL);
}

void gnc_invoice_window_payment_cb (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;
  GncInvoice *invoice = iw_get_invoice(iw);

  if (gncOwnerGetJob (&iw->job))
    gnc_ui_payment_new_with_invoice (&iw->job, iw->book, invoice);
  else
    gnc_ui_payment_new_with_invoice (&iw->owner, iw->book, invoice);
}

/* Sorting callbacks */

void
gnc_invoice_window_sort (InvoiceWindow *iw, invoice_sort_type_t sort_code)
{
  QueryNew *query = gnc_entry_ledger_get_query (iw->ledger);
  GSList *p1 = NULL, *p2 = NULL, *p3 = NULL, *standard;

  if (iw->last_sort == sort_code)
    return;

  standard = g_slist_prepend (NULL, QUERY_DEFAULT_SORT);

  switch (sort_code)
  {
    case BY_STANDARD:
      p1 = standard;
      break;
    case BY_DATE:
      p1 = g_slist_prepend (p1, ENTRY_DATE);
      p2 = standard;
      break;
    case BY_DATE_ENTERED:
      p1 = g_slist_prepend (p1, ENTRY_DATE_ENTERED);
      p2 = standard;
      break;
    case BY_DESC:
      p1 = g_slist_prepend (p1, ENTRY_DESC);
      p2 = standard;
      break;
    case BY_QTY:
      p1 = g_slist_prepend (p1, ENTRY_QTY);
      p2 = standard;
      break;
    case BY_PRICE:
      p1 = g_slist_prepend (p1, ((iw->owner.type == GNC_OWNER_CUSTOMER) ?
                                 ENTRY_IPRICE : ENTRY_BPRICE));
      p2 = standard;
      break;
    default:
      g_slist_free (standard);
      g_return_if_fail (FALSE);
  }

  gncQuerySetSortOrder (query, p1, p2, p3);
  iw->last_sort = sort_code;
  gnc_entry_ledger_display_refresh (iw->ledger);
}

/* Window configuration callbacks */

void
gnc_invoice_window_active_toggled_cb (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;
  GncInvoice *invoice = iw_get_invoice(iw);

  if (!invoice) return;

  gncInvoiceSetActive (invoice,
                       gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)));
}

gboolean
gnc_invoice_window_leave_notes_cb (GtkWidget *widget, GdkEventFocus *event,
                                   gpointer data)
{
  InvoiceWindow *iw = data;
  GncInvoice *invoice = iw_get_invoice(iw);
  GtkTextBuffer* text_buffer;
  GtkTextIter start, end;
  gchar *text;

  if (!invoice) return FALSE;

  text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(iw->notes_text));
  gtk_text_buffer_get_bounds (text_buffer, &start, &end);
  text = gtk_text_buffer_get_text (text_buffer, &start, &end, FALSE);
  gncInvoiceSetNotes (invoice, text);
  return FALSE;
}

static gboolean
gnc_invoice_window_leave_to_charge_cb (GtkWidget *widget, GdkEventFocus *event,
                                       gpointer data)
{
  gnc_amount_edit_evaluate (GNC_AMOUNT_EDIT (widget));
  return FALSE;
}

static void
gnc_invoice_window_changed_to_charge_cb (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;
  GncInvoice *invoice = iw_get_invoice(iw);

  if (!invoice) return;

  gncInvoiceSetToChargeAmount (invoice, gnc_amount_edit_get_amount
                               (GNC_AMOUNT_EDIT (widget)));
}

static GtkWidget *
add_summary_label (GtkWidget *summarybar, const char *label_str)
{
  GtkWidget *hbox;
  GtkWidget *label;

  hbox = gtk_hbox_new(FALSE, 2);
  gtk_box_pack_start (GTK_BOX(summarybar), hbox, FALSE, FALSE, 5);

  label = gtk_label_new (label_str);
  gtk_misc_set_alignment (GTK_MISC(label), 1.0, 0.5);
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);

  label = gtk_label_new ("");
  gtk_misc_set_alignment (GTK_MISC(label), 1.0, 0.5);
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);

  return label;
}

GtkWidget *
gnc_invoice_window_create_summary_bar (InvoiceWindow *iw)
{
  GtkWidget *summarybar;

  iw->total_label           = NULL;
  iw->total_cash_label      = NULL;
  iw->total_charge_label    = NULL;
  iw->total_subtotal_label  = NULL;
  iw->total_tax_label       = NULL;

  summarybar = gtk_hbox_new (FALSE, 4);

  iw->total_label           = add_summary_label (summarybar, _("Total:"));

  switch (gncOwnerGetType (&iw->owner)) {
  case GNC_OWNER_CUSTOMER:
  case GNC_OWNER_VENDOR:
    iw->total_subtotal_label= add_summary_label (summarybar, _("Subtotal:"));
    iw->total_tax_label     = add_summary_label (summarybar, _("Tax:"));
    break;

  case GNC_OWNER_EMPLOYEE:
    iw->total_cash_label    = add_summary_label (summarybar, _("Total Cash:"));
    iw->total_charge_label  = add_summary_label (summarybar, _("Total Charge:"));
    break;

  default:
    break;
  }

  gtk_widget_show_all(summarybar);
  return summarybar;
}

static int
gnc_invoice_job_changed_cb (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;
  GncInvoice *invoice;
  char const *msg = "";
  
  if (!iw)
    return FALSE;

  if (iw->dialog_type == VIEW_INVOICE)
    return FALSE;

  gnc_owner_get_owner (iw->job_choice, &(iw->job));
  invoice = iw_get_invoice (iw);

  if (iw->dialog_type == EDIT_INVOICE)
    return FALSE;

  msg = gncJobGetReference (gncOwnerGetJob (&(iw->job)));
  gtk_entry_set_text (GTK_ENTRY (iw->billing_id_entry), msg ? msg : "");

  return FALSE;

}

static GNCSearchWindow *
gnc_invoice_select_job_cb (gpointer jobp, gpointer user_data)
{
  GncJob *j = jobp;
  InvoiceWindow *iw = user_data;
  GncOwner owner, *ownerp;

  if (!iw) return NULL;

  if (j) {
    ownerp = gncJobGetOwner (j);
    gncOwnerCopy (ownerp, &owner);
  } else
    gncOwnerCopy (&(iw->owner), &owner);

  return gnc_job_search (j, &owner, iw->book);
}

static void
gnc_invoice_update_job_choice (InvoiceWindow *iw)
{
  if (iw->job_choice)
    gtk_container_remove (GTK_CONTAINER (iw->job_box), iw->job_choice);

  /* If we don't have a real owner, then we obviously can't have a job */
  if (iw->owner.owner.undefined == NULL) {
    iw->job_choice = NULL;

  } else
    switch (iw->dialog_type) {
    case VIEW_INVOICE:
    case EDIT_INVOICE:
      iw->job_choice =
        gnc_owner_edit_create (NULL, iw->job_box, iw->book, &(iw->job));
      break;
    case NEW_INVOICE:
    case MOD_INVOICE:
      iw->job_choice =
        gnc_general_search_new (GNC_JOB_MODULE_NAME, _("Select..."),
                                gnc_invoice_select_job_cb, iw);

      gnc_general_search_set_selected (GNC_GENERAL_SEARCH (iw->job_choice),
                                       gncOwnerGetJob (&iw->job));
      gnc_general_search_allow_clear (GNC_GENERAL_SEARCH (iw->job_choice),
                                      TRUE);
      gtk_box_pack_start (GTK_BOX (iw->job_box), iw->job_choice,
                          TRUE, TRUE, 0);
      
      g_signal_connect (G_OBJECT (iw->job_choice), "changed",
                        G_CALLBACK (gnc_invoice_job_changed_cb), iw);
      break;
    }
  
  if (iw->job_choice)
    gtk_widget_show_all (iw->job_choice);
}

static GNCSearchWindow *
gnc_invoice_select_proj_job_cb (gpointer jobp, gpointer user_data)
{
  GncJob *j = jobp;
  InvoiceWindow *iw = user_data;
  GncOwner owner, *ownerp;

  if (!iw) return NULL;

  if (j) {
    ownerp = gncJobGetOwner (j);
    gncOwnerCopy (ownerp, &owner);
  } else
    gncOwnerCopy (&(iw->proj_cust), &owner);

  return gnc_job_search (j, &owner, iw->book);
}

static int
gnc_invoice_proj_job_changed_cb (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;
  
  if (!iw)
    return FALSE;

  if (iw->dialog_type == VIEW_INVOICE)
    return FALSE;

  gnc_owner_get_owner (iw->proj_job_choice, &(iw->proj_job));
  return FALSE;
}

static void
gnc_invoice_update_proj_job (InvoiceWindow *iw)
{
  if (iw->proj_job_choice)
    gtk_container_remove (GTK_CONTAINER (iw->proj_job_box),
                          iw->proj_job_choice);

  switch (iw->dialog_type) {
  case VIEW_INVOICE:
  case EDIT_INVOICE:
      iw->proj_job_choice =
        gnc_owner_edit_create (NULL, iw->proj_job_box, iw->book, &(iw->job));
    break;
  case NEW_INVOICE:
  case MOD_INVOICE:
    if (iw->proj_cust.owner.undefined == NULL) {
      iw->proj_job_choice = NULL;
    } else {
      iw->proj_job_choice =
        gnc_general_search_new (GNC_JOB_MODULE_NAME, _("Select..."),
                                gnc_invoice_select_proj_job_cb, iw);

      gnc_general_search_set_selected (GNC_GENERAL_SEARCH(iw->proj_job_choice),
                                       gncOwnerGetJob (&iw->proj_job));
      gnc_general_search_allow_clear (GNC_GENERAL_SEARCH (iw->proj_job_choice),
                                      TRUE);
      gtk_box_pack_start (GTK_BOX (iw->proj_job_box), iw->proj_job_choice,
                          TRUE, TRUE, 0);
      
      g_signal_connect (G_OBJECT (iw->proj_job_choice), "changed",
                        G_CALLBACK (gnc_invoice_proj_job_changed_cb), iw);
    }
    break;
  }

  if (iw->proj_job_choice)
    gtk_widget_show_all (iw->proj_job_choice);
}

static int
gnc_invoice_owner_changed_cb (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;
  GncBillTerm *term = NULL;
  GncOwner owner;
  
  if (!iw)
    return FALSE;

  if (iw->dialog_type == VIEW_INVOICE)
    return FALSE;

  gncOwnerCopy (&(iw->owner), &owner);
  gnc_owner_get_owner (iw->owner_choice, &owner);

  /* If this owner really changed, then reset ourselves */
  if (!gncOwnerEqual (&owner, &(iw->owner))) {
    GncInvoice *invoice;

    gncOwnerCopy (&owner, &(iw->owner));
    gncOwnerInitJob (&(iw->job), NULL);
    invoice = iw_get_invoice (iw);
    gnc_entry_ledger_reset_query (iw->ledger);
  }

  if (iw->dialog_type == EDIT_INVOICE)
    return FALSE;

  switch (gncOwnerGetType (&(iw->owner))) {
  case GNC_OWNER_CUSTOMER:
    term = gncCustomerGetTerms (gncOwnerGetCustomer (&(iw->owner)));
    break;
  case GNC_OWNER_VENDOR:
    term = gncVendorGetTerms (gncOwnerGetVendor (&(iw->owner)));
    break;
  case GNC_OWNER_EMPLOYEE:
    term = NULL;
    break;
  default:
    g_warning ("Unknown owner type: %d\n", gncOwnerGetType (&(iw->owner)));
    break;
  }

  /* XXX: I'm not sure -- should we change the terms if this happens? */
  iw->terms = term;
  gnc_ui_optionmenu_set_value (iw->terms_menu, iw->terms);

  gnc_invoice_update_job_choice (iw);

  return FALSE;
}

static int
gnc_invoice_proj_cust_changed_cb (GtkWidget *widget, gpointer data)
{
  InvoiceWindow *iw = data;
  GncOwner owner;
  
  if (!iw)
    return FALSE;

  if (iw->dialog_type == VIEW_INVOICE)
    return FALSE;

  gncOwnerCopy (&(iw->proj_cust), &owner);
  gnc_owner_get_owner (iw->proj_cust_choice, &owner);

  /* If this owner really changed, then reset ourselves */
  if (!gncOwnerEqual (&owner, &(iw->proj_cust))) {
    gncOwnerCopy (&owner, &(iw->proj_cust));
    gncOwnerInitJob (&(iw->proj_job), NULL);
  }

  if (iw->dialog_type == EDIT_INVOICE)
    return FALSE;

  gnc_invoice_update_proj_job (iw);

  return FALSE;
}

static void
gnc_invoice_dialog_close_handler (gpointer user_data)
{
  InvoiceWindow *iw = user_data;

  if (iw) {
    gtk_widget_destroy (iw->dialog);
  }
}

static void
gnc_invoice_window_close_handler (gpointer user_data)
{
  InvoiceWindow *iw = user_data;

  if (iw) {
    gnc_main_window_close_page(iw->page);
    iw->page = NULL;
  }
}

static void
gnc_invoice_reset_total_label (GtkLabel *label, gnc_numeric amt, gnc_commodity *com)
{
  char string[256];

  amt = gnc_numeric_convert (amt, gnc_commodity_get_fraction(com), GNC_RND_ROUND);
  xaccSPrintAmount (string, amt, gnc_default_print_info (TRUE));
  gtk_label_set_text (label, string);
}

static void
gnc_invoice_redraw_all_cb (GnucashRegister *g_reg, gpointer data)
{
  InvoiceWindow *iw = data;
  GncInvoice * invoice;
  gnc_commodity * currency;
  gnc_numeric amount, to_charge_amt = gnc_numeric_zero();

  if (!iw)
    return;

  //  if (iw)
  //    gnc_invoice_update_window (iw, NULL);

  invoice = iw_get_invoice (iw);
  if (!invoice)
    return;

  currency = gncInvoiceGetCurrency (invoice);

  if (iw->total_label) {
    amount = gncInvoiceGetTotal (invoice);
    gnc_invoice_reset_total_label (GTK_LABEL (iw->total_label), amount, currency);
  }

  if (iw->total_subtotal_label) {
    amount = gncInvoiceGetTotalSubtotal (invoice);
    gnc_invoice_reset_total_label (GTK_LABEL (iw->total_subtotal_label), amount, currency);
  }

  if (iw->total_tax_label) {
    amount = gncInvoiceGetTotalTax (invoice);
    gnc_invoice_reset_total_label (GTK_LABEL (iw->total_tax_label), amount, currency);
  }

  /* Deal with extra items for the expense voucher */

  if (iw->to_charge_edit) {
    gnc_amount_edit_evaluate (GNC_AMOUNT_EDIT (iw->to_charge_edit));
    to_charge_amt = gnc_amount_edit_get_amount(GNC_AMOUNT_EDIT(iw->to_charge_edit));
  }

  if (iw->total_cash_label) {
    amount = gncInvoiceGetTotalOf (invoice, GNC_PAYMENT_CASH);
    amount = gnc_numeric_sub (amount, to_charge_amt,
                              gnc_commodity_get_fraction (currency), GNC_RND_ROUND);
    gnc_invoice_reset_total_label (GTK_LABEL (iw->total_cash_label), amount, currency);
  }

  if (iw->total_charge_label) {
    amount = gncInvoiceGetTotalOf (invoice, GNC_PAYMENT_CARD);
    amount = gnc_numeric_add (amount, to_charge_amt, 
                              gnc_commodity_get_fraction (currency), GNC_RND_ROUND);
    gnc_invoice_reset_total_label (G