static gint
_freq_comparator(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer user_data)
{
GncSxListTreeModelAdapter *adapter = GNC_SX_LIST_TREE_MODEL_ADAPTER(user_data);
GncSxInstances *a_inst, *b_inst;
a_inst = gsltma_get_sx_instances_from_orig_iter(adapter, a);
b_inst = gsltma_get_sx_instances_from_orig_iter(adapter, b);
if (a_inst == NULL && b_inst == NULL) return 0;
if (a_inst == NULL) return 1;
if (b_inst == NULL) return -1;
return recurrenceListCmp(gnc_sx_get_schedule(a_inst->sx), gnc_sx_get_schedule(b_inst->sx));
}
static void
gsltma_populate_tree_store(GncSxListTreeModelAdapter *model)
{
GtkTreeIter iter;
GList *list;
for (list = model->instances->sx_instance_list; list != NULL; list = list->next)
{
GncSxInstances *instances = (GncSxInstances*)list->data;
gchar *frequency_str;
char last_occur_date_buf[MAX_DATE_LENGTH+1];
char next_occur_date_buf[MAX_DATE_LENGTH+1];
frequency_str = recurrenceListToCompactString(gnc_sx_get_schedule(instances->sx));
_format_conditional_date(xaccSchedXactionGetLastOccurDate(instances->sx),
last_occur_date_buf, MAX_DATE_LENGTH);
_format_conditional_date(&instances->next_instance_date,
next_occur_date_buf, MAX_DATE_LENGTH);
gtk_tree_store_append(model->orig, &iter, NULL);
gtk_tree_store_set(model->orig, &iter,
SXLTMA_COL_NAME, xaccSchedXactionGetName(instances->sx),
SXLTMA_COL_ENABLED, xaccSchedXactionGetEnabled(instances->sx),
SXLTMA_COL_FREQUENCY, frequency_str,
SXLTMA_COL_LAST_OCCUR, last_occur_date_buf,
SXLTMA_COL_NEXT_OCCUR, next_occur_date_buf,
-1);
g_free(frequency_str);
}
}
/* ================================================================= */
bool
GncSqlSchedXactionBackend::commit (GncSqlBackend* sql_be, QofInstance* inst)
{
SchedXaction* pSx;
const GncGUID* guid;
E_DB_OPERATION op;
gboolean is_infant;
gboolean is_ok;
g_return_val_if_fail (sql_be != NULL, FALSE);
g_return_val_if_fail (inst != NULL, FALSE);
g_return_val_if_fail (GNC_IS_SX (inst), FALSE);
pSx = GNC_SX (inst);
is_infant = qof_instance_get_infant (inst);
if (qof_instance_get_destroying (inst))
{
op = OP_DB_DELETE;
}
else if (sql_be->pristine() || is_infant)
{
op = OP_DB_INSERT;
}
else
{
op = OP_DB_UPDATE;
}
is_ok = sql_be->do_db_operation(op, SCHEDXACTION_TABLE, GNC_SX_ID, pSx,
col_table);
guid = qof_instance_get_guid (inst);
if (op == OP_DB_INSERT || op == OP_DB_UPDATE)
{
gnc_sql_recurrence_save_list (sql_be, guid, gnc_sx_get_schedule (pSx));
}
else
{
gnc_sql_recurrence_delete (sql_be, guid);
}
if (is_ok)
{
// Now, commit any slots
if (op == OP_DB_INSERT || op == OP_DB_UPDATE)
{
is_ok = gnc_sql_slots_save (sql_be, guid, is_infant, inst);
}
else
{
is_ok = gnc_sql_slots_delete (sql_be, guid);
}
}
return is_ok;
}
static gchar*
gsidca_get_info(GncDenseCalModel *model, guint tag)
{
GncSxInstanceDenseCalAdapter *adapter = GNC_SX_INSTANCE_DENSE_CAL_ADAPTER(model);
// g_list_find(instances->sxes, {sx_to_tag, tag}).get_freq_spec().get_freq_str();
GList *schedule;
gchar *schedule_str;
GncSxInstances *insts
= (GncSxInstances*)g_list_find_custom(adapter->instances->sx_instance_list, GUINT_TO_POINTER(tag), gsidca_find_sx_with_tag)->data;
if (insts == NULL)
return NULL;
schedule = gnc_sx_get_schedule(insts->sx);
schedule_str = recurrenceListToCompactString(schedule);
return schedule_str;
}
static void
gnc_plugin_page_sx_list_cmd_new(GtkAction *action, GncPluginPageSxList *page)
{
SchedXaction *new_sx;
gboolean new_sx_flag = TRUE;
new_sx = xaccSchedXactionMalloc(gnc_get_current_book());
{
GDate now;
Recurrence *r = new Recurrence;//g_new0(Recurrence, 1);
g_date_clear(&now, 1);
gnc_gdate_set_today (&now);
recurrenceSet(r, 1, PERIOD_MONTH, &now, WEEKEND_ADJ_NONE);
RecurrenceList_t schedule = gnc_sx_get_schedule(new_sx);
schedule.push_back(r);
gnc_sx_set_schedule(new_sx, schedule);
}
gnc_ui_scheduled_xaction_editor_dialog_create(new_sx, new_sx_flag);
}
xmlNodePtr
gnc_schedXaction_dom_tree_create(SchedXaction *sx)
{
xmlNodePtr ret;
const GDate *date;
gint instCount;
const GncGUID *templ_acc_guid;
gboolean allow_2_2_incompat = TRUE;
gchar *name = g_strdup (xaccSchedXactionGetName(sx));
templ_acc_guid = xaccAccountGetGUID(sx->template_acct);
/* FIXME: this should be the same as the def in io-gncxml-v2.c */
ret = xmlNewNode (NULL, BAD_CAST GNC_SCHEDXACTION_TAG);
if (allow_2_2_incompat)
xmlSetProp(ret, BAD_CAST "version", BAD_CAST schedxaction_version2_string);
else
xmlSetProp(ret, BAD_CAST "version", BAD_CAST schedxaction_version_string);
xmlAddChild( ret,
guid_to_dom_tree(SX_ID,
xaccSchedXactionGetGUID(sx)) );
xmlNewTextChild( ret, NULL, BAD_CAST SX_NAME, checked_char_cast (name));
g_free (name);
if (allow_2_2_incompat)
{
xmlNewTextChild( ret, NULL, BAD_CAST SX_ENABLED,
BAD_CAST ( sx->enabled ? "y" : "n" ) );
}
xmlNewTextChild( ret, NULL, BAD_CAST SX_AUTOCREATE,
BAD_CAST ( sx->autoCreateOption ? "y" : "n" ) );
xmlNewTextChild( ret, NULL, BAD_CAST SX_AUTOCREATE_NOTIFY,
BAD_CAST ( sx->autoCreateNotify ? "y" : "n" ) );
xmlAddChild(ret, int_to_dom_tree(SX_ADVANCE_CREATE_DAYS,
sx->advanceCreateDays));
xmlAddChild(ret, int_to_dom_tree(SX_ADVANCE_REMIND_DAYS,
sx->advanceRemindDays));
instCount = gnc_sx_get_instance_count( sx, NULL );
xmlAddChild( ret, int_to_dom_tree( SX_INSTANCE_COUNT,
instCount ) );
xmlAddChild( ret,
gdate_to_dom_tree( SX_START,
xaccSchedXactionGetStartDate(sx) ) );
date = xaccSchedXactionGetLastOccurDate(sx);
if ( g_date_valid( date ) )
{
xmlAddChild( ret, gdate_to_dom_tree( SX_LAST, date ) );
}
if ( xaccSchedXactionHasOccurDef(sx) )
{
xmlAddChild(ret, int_to_dom_tree( SX_NUM_OCCUR,
xaccSchedXactionGetNumOccur(sx)));
xmlAddChild(ret, int_to_dom_tree( SX_REM_OCCUR,
xaccSchedXactionGetRemOccur(sx)));
}
else if ( xaccSchedXactionHasEndDate(sx) )
{
xmlAddChild( ret,
gdate_to_dom_tree( SX_END,
xaccSchedXactionGetEndDate(sx) ) );
}
/* output template account GncGUID */
xmlAddChild( ret,
guid_to_dom_tree(SX_TEMPL_ACCT,
templ_acc_guid));
if (allow_2_2_incompat)
{
xmlNodePtr schedule_node = xmlNewNode(NULL,
BAD_CAST "sx:schedule");
GList *schedule = gnc_sx_get_schedule(sx);
for (; schedule != NULL; schedule = schedule->next)
{
xmlAddChild(schedule_node, recurrence_to_dom_tree("gnc:recurrence", (Recurrence*)schedule->data));
}
xmlAddChild(ret, schedule_node);
}
/* Output deferred-instance list. */
{
xmlNodePtr instNode;
SXTmpStateData *tsd;
GList *l;
for ( l = gnc_sx_get_defer_instances( sx ); l; l = l->next )
{
tsd = (SXTmpStateData*)l->data;
instNode = xmlNewNode( NULL, BAD_CAST SX_DEFER_INSTANCE );
if ( g_date_valid( &tsd->last_date ) )
{
xmlAddChild( instNode, gdate_to_dom_tree( SX_LAST,
&tsd->last_date ) );
}
xmlAddChild( instNode, int_to_dom_tree( SX_REM_OCCUR,
tsd->num_occur_rem ) );
xmlAddChild( instNode, int_to_dom_tree( SX_INSTANCE_COUNT,
tsd->num_inst ) );
xmlAddChild( ret, instNode );
}
}
/* output kvp_frame */
{
xmlNodePtr kvpnode =
kvp_frame_to_dom_tree( SX_SLOTS,
xaccSchedXactionGetSlots(sx) );
if ( kvpnode )
{
xmlAddChild(ret, kvpnode);
}
}
return ret;
}
