void gnc_dialog_query_view_refresh (DialogQueryView *dqv)
{
if (!dqv) return;
gnc_query_view_refresh (GNC_QUERY_VIEW(dqv->qview));
gtk_widget_show_all (dqv->dialog);
}
static void
gnc_search_callback_button_execute (GNCSearchCallbackButton *cb,
GNCSearchWindow *sw)
{
GNCQueryView *qview = GNC_QUERY_VIEW(sw->result_view);
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreeIter iter;
// Sanity check
g_assert(qview);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(qview));
g_assert(gtk_tree_selection_get_mode(selection) == GTK_SELECTION_MULTIPLE);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(qview));
/* Do we have a callback for multi-selections ? */
if (cb->cb_multiselect_fn && (!cb->cb_fcn ))
{
/* We have allready populated the selected_item_list from the select row callback */
// We use g_list_prepend (for performance reasons), so we have to reverse once here
sw->selected_item_list = g_list_reverse(sw->selected_item_list);
// Call the callback
(cb->cb_multiselect_fn)(sw->selected_item_list, sw->user_data);
}
else
{
// No, stick to the single-item callback
if (cb->cb_fcn)
(cb->cb_fcn)(&(sw->selected_item), sw->user_data);
}
}
void gnc_dialog_query_view_set_numerics (DialogQueryView *dqv, gboolean abs,
gboolean inv_sort)
{
if (!dqv) return;
gnc_query_view_set_numerics (GNC_QUERY_VIEW(dqv->qview), abs, inv_sort);
}
static gboolean
gnc_reconcile_view_key_press_cb (GtkWidget *widget, GdkEventKey *event,
gpointer user_data)
{
GNCReconcileView *view = GNC_RECONCILE_VIEW(user_data);
GNCQueryView *qview = GNC_QUERY_VIEW(widget);
GtkTreeModel *model;
GtkTreeIter iter;
gpointer entry, pointer;
gboolean valid, toggle;
switch (event->keyval)
{
case GDK_KEY_space:
g_signal_stop_emission_by_name (widget, "key_press_event");
toggle = gnc_reconcile_view_set_toggle (view);
gnc_reconcile_view_set_list (view, toggle);
return TRUE;
break;
default:
return FALSE;
}
}
void
gnc_reconcile_view_set_list ( GNCReconcileView *view, gboolean reconcile)
{
GNCQueryView *qview = GNC_QUERY_VIEW(view);
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreeIter iter;
gpointer entry;
gboolean toggled;
GList *node;
GList *list_of_rows;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (qview));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (qview));
list_of_rows = gtk_tree_selection_get_selected_rows (selection, &model);
/* We get a list of TreePaths */
for(node = list_of_rows; node; node = node->next)
{
GtkTreeIter iter;
if(gtk_tree_model_get_iter(model, &iter, node->data))
{
/* now iter is a valid row iterator */
gtk_tree_model_get (model, &iter, 0, &entry, -1);
gtk_tree_model_get (model, &iter, 5, &toggled, -1);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, 5, reconcile, -1);
if(reconcile != toggled)
gnc_reconcile_view_toggle (view, entry);
}
gtk_tree_path_free(node->data);
}
g_list_free(list_of_rows);
}
gint
gnc_reconcile_view_get_num_splits (GNCReconcileView *view)
{
g_return_val_if_fail (view != NULL, 0);
g_return_val_if_fail (GNC_IS_RECONCILE_VIEW (view), 0);
return gnc_query_view_get_num_entries (GNC_QUERY_VIEW (view));
}
Split *
gnc_reconcile_view_get_current_split (GNCReconcileView *view)
{
g_return_val_if_fail (view != NULL, NULL);
g_return_val_if_fail (GNC_IS_RECONCILE_VIEW (view), NULL);
return gnc_query_view_get_selected_entry (GNC_QUERY_VIEW (view));
}
/********************************************************************\
* gnc_reconcile_view_unselect_all *
* unselect all splits in the view *
* *
* Args: view - view to unselect all *
* Returns: nothing *
\********************************************************************/
void
gnc_reconcile_view_unselect_all(GNCReconcileView *view)
{
g_return_if_fail (view != NULL);
g_return_if_fail (GNC_IS_RECONCILE_VIEW (view));
gnc_query_view_unselect_all (GNC_QUERY_VIEW (view));
}
gint
gnc_reconcile_view_num_selected (GNCReconcileView *view )
{
GNCQueryView *qview = GNC_QUERY_VIEW(view);
GtkTreeSelection *selection;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (qview));
return gtk_tree_selection_count_selected_rows (selection);
}
/********************************************************************\
* gnc_reconcile_view_refresh *
* refreshes the view *
* *
* Args: view - view to refresh *
* Returns: nothing *
\********************************************************************/
static void
grv_refresh_helper (gpointer key, gpointer value, gpointer user_data)
{
GNCReconcileView *view = user_data;
GNCQueryView *qview = GNC_QUERY_VIEW (view);
if (!gnc_query_view_item_in_view (qview, key))
g_hash_table_remove (view->reconciled, key);
}
gint
gnc_reconcile_view_get_column_width (GNCReconcileView *view, gint column)
{
GNCQueryView *qview = GNC_QUERY_VIEW (view);
GtkTreeViewColumn *col;
//allow for pointer model column at column 0
col = gtk_tree_view_get_column (GTK_TREE_VIEW (qview), (column - 1));
return gtk_tree_view_column_get_width (col);
}
static void
gnc_search_dialog_init_result_view (GNCSearchWindow *sw)
{
GtkTreeSelection *selection;
sw->result_view = gnc_query_view_new(sw->display_list, sw->q);
// We want the multi-selection mode of the tree view.
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(sw->result_view));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
/* Set the sort order of the tree view */
gnc_query_sort_order(GNC_QUERY_VIEW(sw->result_view), 1, GTK_SORT_ASCENDING);
/* Setup the list callbacks */
g_signal_connect (GNC_QUERY_VIEW(sw->result_view), "row_selected",
G_CALLBACK (gnc_search_dialog_select_row_cb), sw);
g_signal_connect (GNC_QUERY_VIEW(sw->result_view), "double_click_entry",
G_CALLBACK(gnc_search_dialog_double_click_cb), sw);
}
/********************************************************************\
* gnc_reconcile_view_postpone *
* postpone the reconcile information in the view by setting *
* reconciled splits to cleared status *
* *
* Args: view - view to commit *
* Returns: nothing *
\********************************************************************/
void
gnc_reconcile_view_postpone (GNCReconcileView *view)
{
GtkTreeModel *model;
GtkTreeIter iter;
int num_splits;
int i;
gpointer entry = NULL;
g_return_if_fail (view != NULL);
g_return_if_fail (GNC_IS_RECONCILE_VIEW (view));
if (view->reconciled == NULL)
return;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (GNC_QUERY_VIEW (view)));
gtk_tree_model_get_iter_first (model, &iter);
num_splits = gnc_query_view_get_num_entries (GNC_QUERY_VIEW (view));
gnc_suspend_gui_refresh();
for (i = 0; i < num_splits; i++)
{
char recn;
gtk_tree_model_get (model, &iter, REC_POINTER, &entry, -1);
// Don't change splits past reconciliation date that haven't been
// set to be reconciled
if (gnc_difftime (view->statement_date,
xaccTransGetDate (xaccSplitGetParent (entry))) >= 0 ||
g_hash_table_lookup (view->reconciled, entry))
{
recn = g_hash_table_lookup (view->reconciled, entry) ? CREC : NREC;
xaccSplitSetReconcile (entry, recn);
}
gtk_tree_model_iter_next (model, &iter);
}
gnc_resume_gui_refresh();
}
DialogQueryView *
gnc_dialog_query_view_create (GList *param_list, Query *q,
const char *title, const char *label,
gboolean abs, gboolean inv_sort,
gint sort_column, GtkSortType order,
GNCDisplayViewButton *buttons, gpointer user_data)
{
DialogQueryView *dqv;
if (!param_list || !q)
return NULL;
dqv = gnc_dialog_query_view_new (param_list, q);
if (!dqv)
return NULL;
if (title)
gnc_dialog_query_view_set_title (dqv, title);
if (label)
gnc_dialog_query_view_set_label (dqv, label);
gnc_dialog_query_view_set_numerics (dqv, abs, inv_sort);
if (buttons)
gnc_dialog_query_view_set_buttons (dqv, buttons, user_data);
gnc_dialog_query_view_refresh (dqv);
/* Set the sort order */
gnc_query_sort_order (GNC_QUERY_VIEW (dqv->qview), sort_column, order);
/* Unselect all rows */
gnc_query_view_unselect_all (GNC_QUERY_VIEW (dqv->qview));
return dqv;
}
void
gnc_reconcile_view_refresh (GNCReconcileView *view)
{
GNCQueryView *qview;
g_return_if_fail (view != NULL);
g_return_if_fail (GNC_IS_RECONCILE_VIEW (view));
qview = GNC_QUERY_VIEW (view);
gnc_query_view_refresh (qview);
/* Now verify that everything in the reconcile hash is still in qview */
if (view->reconciled)
g_hash_table_foreach (view->reconciled, grv_refresh_helper, view);
}
static void
gnc_dialog_query_view_button_clicked (GtkButton *button, DialogQueryView *dqv)
{
GNCDisplayViewButton *cb;
gpointer entry;
g_return_if_fail (dqv);
entry = gnc_query_view_get_selected_entry (GNC_QUERY_VIEW (dqv->qview));
if (!entry)
return;
cb = g_object_get_data (G_OBJECT (button), "data");
g_return_if_fail (cb);
gnc_dialog_query_run_callback (cb, entry, dqv);
}
/****************************************************************************\
* gnc_reconcile_view_new *
* creates the account tree *
* *
* Args: account - the account to use in filling up the splits. *
* type - the type of view, RECLIST_DEBIT or RECLIST_CREDIT *
* statement_date - date of statement *
* Returns: the account tree widget, or NULL if there was a problem. *
\****************************************************************************/
static void
gnc_reconcile_view_construct (GNCReconcileView *view, Query *query)
{
GNCQueryView *qview = GNC_QUERY_VIEW (view);
GtkTreeViewColumn *col;
GtkTreeSelection *selection;
GList *renderers;
GtkCellRenderer *cr0;
gboolean inv_sort = FALSE;
if (view->view_type == RECLIST_CREDIT)
inv_sort = TRUE;
/* Construct the view */
gnc_query_view_construct (qview, view->column_list, query);
gnc_query_view_set_numerics (qview, TRUE, inv_sort);
/* Set the description field to have spare space,
REC_DESC -1 to allow for the pointer model column at 0 */
col = gtk_tree_view_get_column (GTK_TREE_VIEW (qview), (REC_DESC - 1));
gtk_tree_view_column_set_expand (col, TRUE);
/* Get the renderer of the description column and set ellipsize value */
renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (col));
cr0 = g_list_nth_data (renderers, 0);
g_list_free (renderers);
g_object_set (cr0, "ellipsize", PANGO_ELLIPSIZE_END, NULL );
gtk_widget_set_has_tooltip (GTK_WIDGET (qview), TRUE);
/* Set the selection method */
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (qview));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
/* Now set up the signals for the QueryView */
g_signal_connect (G_OBJECT (qview), "column_toggled",
G_CALLBACK (gnc_reconcile_view_line_toggled), view);
g_signal_connect (G_OBJECT (qview), "double_click_entry",
G_CALLBACK (gnc_reconcile_view_double_click_entry), view);
g_signal_connect (G_OBJECT (qview), "row_selected",
G_CALLBACK (gnc_reconcile_view_row_selected), view);
g_signal_connect (G_OBJECT (qview), "key_press_event",
G_CALLBACK (gnc_reconcile_view_key_press_cb), view);
g_signal_connect (G_OBJECT (qview), "query-tooltip",
G_CALLBACK (gnc_reconcile_view_tooltip_cb), view);
}
void
gnc_reconcile_view_add_padding (GNCReconcileView *view, gint column, gint xpadding)
{
GNCQueryView *qview = GNC_QUERY_VIEW (view);
GtkTreeViewColumn *col;
GList *renderers;
GtkCellRenderer *cr0;
gint xpad, ypad;
//allow for pointer model column at column 0
col = gtk_tree_view_get_column (GTK_TREE_VIEW (qview), (column - 1));
renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (col));
cr0 = g_list_nth_data (renderers, 0);
g_list_free (renderers);
gtk_cell_renderer_get_padding (cr0, &xpad, &ypad);
gtk_cell_renderer_set_padding (cr0, xpadding, ypad);
}
static gboolean
gnc_reconcile_view_set_toggle (GNCReconcileView *view)
{
GNCQueryView *qview = GNC_QUERY_VIEW(view);
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreeIter iter;
gboolean toggled;
GList *node;
GList *list_of_rows;
gint num_toggled = 0;
gint num_selected = 0;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (qview));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (qview));
list_of_rows = gtk_tree_selection_get_selected_rows (selection, &model);
num_selected = gtk_tree_selection_count_selected_rows (selection);
/* We get a list of TreePaths */
for(node = list_of_rows; node; node = node->next)
{
GtkTreeIter iter;
toggled = FALSE;
if(gtk_tree_model_get_iter(model, &iter, node->data))
{
/* now iter is a valid row iterator */
gtk_tree_model_get (model, &iter, 5, &toggled, -1);
if(toggled)
num_toggled++;
}
gtk_tree_path_free(node->data);
}
g_list_free(list_of_rows);
if(num_toggled == num_selected)
return FALSE;
else
return TRUE;
}
void
gnc_reconcile_view_set_list ( GNCReconcileView *view, gboolean reconcile)
{
GNCQueryView *qview = GNC_QUERY_VIEW(view);
GtkTreeSelection *selection;
GtkTreeModel *model;
gpointer entry;
gboolean toggled;
GList *node;
GList *list_of_rows;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (qview));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (qview));
list_of_rows = gtk_tree_selection_get_selected_rows (selection, &model);
/* We get a list of TreePaths */
for(node = list_of_rows; node; node = node->next)
{
GtkTreeIter iter;
if(gtk_tree_model_get_iter(model, &iter, node->data))
{
/* now iter is a valid row iterator */
gtk_tree_model_get (model, &iter, REC_POINTER, &entry, -1);
gtk_tree_model_get (model, &iter, REC_RECN, &toggled, -1);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, REC_RECN, reconcile, -1);
if(reconcile != toggled)
gnc_reconcile_view_toggle (view, entry);
}
gtk_tree_path_free(node->data);
}
// Out of site toggles on selected rows may not appear correctly drawn so
// queue a draw for the treeview widget
gtk_widget_queue_draw (GTK_WIDGET(qview));
g_list_free(list_of_rows);
}
static void
gnc_search_dialog_display_results (GNCSearchWindow *sw)
{
gdouble max_count;
/* Check if this is the first time this is called for this window.
* If so, then build the results sub-window, the scrolled treeview,
* and the active buttons.
*/
if (sw->result_view == NULL)
{
GtkWidget *scroller, *frame, *button_box, *button;
/* Create the view */
gnc_search_dialog_init_result_view (sw);
frame = gtk_frame_new(NULL);
/* Create the scroller and add the view to the scroller */
scroller = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroller),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request(GTK_WIDGET(scroller), 300, 100);
gtk_container_add (GTK_CONTAINER (scroller), sw->result_view);
gtk_container_add(GTK_CONTAINER(frame), scroller);
/* Create the button_box */
button_box = gtk_vbox_new (FALSE, 3);
/* ... and add all the buttons */
if (sw->buttons)
{
int i;
button = gtk_button_new_with_label (_("Select"));
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (gnc_search_dialog_select_cb), sw);
gtk_box_pack_start (GTK_BOX (button_box), button, FALSE, FALSE, 3);
sw->select_button = button;
for (i = 0; sw->buttons[i].label; i++)
{
GNCSearchCallbackButton* button_spec = sw->buttons + i;
button = gtk_button_new_with_label (_(button_spec->label));
g_object_set_data (G_OBJECT (button), "data", button_spec);
if (qof_book_is_readonly (gnc_get_current_book ()))
gtk_widget_set_sensitive (GTK_WIDGET(button), button_spec->sensitive_if_readonly);
/* Save the button pointer */
sw->button_list = g_list_append(sw->button_list, button);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (gnc_search_dialog_result_clicked), sw);
gtk_box_pack_start (GTK_BOX (button_box), button, FALSE, FALSE, 3);
}
}
/* Add the scrolled-view and button-box to the results_box */
gtk_box_pack_end (GTK_BOX (sw->result_hbox), button_box, FALSE, FALSE, 3);
gtk_box_pack_end (GTK_BOX (sw->result_hbox), frame, TRUE, TRUE, 3);
/* And show the results */
gtk_widget_show_all (sw->result_hbox);
/* But may be hide the select button */
if (!sw->selected_cb)
gtk_widget_hide (sw->select_button);
}
else
/* Update the query in the view */
gnc_query_view_reset_query (GNC_QUERY_VIEW(sw->result_view), sw->q);
/* Deselect all the select buttons and any items */
gnc_search_dialog_select_buttons_enable (sw, 0);
gnc_query_view_unselect_all (GNC_QUERY_VIEW(sw->result_view));
/* set 'new search' if fewer than max_count items is returned. */
max_count = gnc_prefs_get_float(GNC_PREFS_GROUP_SEARCH_GENERAL, GNC_PREF_NEW_SEARCH_LIMIT);
if (gnc_query_view_get_num_entries(GNC_QUERY_VIEW(sw->result_view)) < max_count)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (sw->new_rb), TRUE);
}
static void
gnc_reconcile_view_toggle_children (Account *account, GNCReconcileView *view, Split *split)
{
GList *child_accounts, *node;
Transaction *transaction;
/*
* Need to get all splits in this transaction and identify any that are
* in the same hierarchy as the account being reconciled (not necessarily
* the account this split is from.)
*
* For each of these splits toggle them all to the same state.
*/
child_accounts = gnc_account_get_descendants (account);
child_accounts = g_list_prepend (child_accounts, account);
transaction = xaccSplitGetParent (split);
for (node = xaccTransGetSplitList (transaction); node; node = node->next)
{
Split *other_split;
Account *other_account;
GNCReconcileView *current_view;
GtkTreeModel *model;
GtkTreeIter iter;
gboolean valid;
gpointer pointer;
other_split = node->data;
other_account = xaccSplitGetAccount (other_split);
if (other_split == split)
continue;
/* Check this 'other' account in in the same hierarchy */
if (!g_list_find (child_accounts, other_account))
continue;
/* Search our sibling view for this split first. We search the
* sibling list first because that it where it is most likely to be.
*/
current_view = view->sibling;
if (!gnc_query_view_item_in_view (GNC_QUERY_VIEW (current_view), other_split))
{
/* Not in the sibling view, try this view */
current_view = view;
if (!gnc_query_view_item_in_view (GNC_QUERY_VIEW (current_view), other_split))
/* We can't find it, nothing more I can do about it */
continue;
}
/* Found the other split. Toggle the reconciled check mark in the view... */
model = gtk_tree_view_get_model (GTK_TREE_VIEW (current_view));
valid = gtk_tree_model_get_iter_first (model, &iter);
while (valid)
{
// Walk through the list, reading each row
gtk_tree_model_get (model, &iter, REC_POINTER, &pointer, -1);
if(pointer == other_split)
{
gboolean toggled;
gtk_tree_model_get (model, &iter, REC_RECN, &toggled, -1);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, REC_RECN, !toggled, -1);
break;
}
valid = gtk_tree_model_iter_next (model, &iter);
}
/* ...and toggle its reconciled state in the internal hash */
gnc_reconcile_view_toggle_split (current_view, other_split);
}
g_list_free (child_accounts);
}
