Files
file	FreqSpec.h
	Period / Date Frequency Specification.

file	SchedXaction.h
	Scheduled Transactions public handling routines.

file	SX-book.h
	Anchor Scheduled Transaction info in a book. See src/doc/books.txt for design overview.

Data Structures
struct	_SchedXaction

struct	_SchedXactionClass

struct	_SXTmpStateData

struct	xaccSchedXactionsDef

struct	_SchedXactionsClass

Macros
#define	ENUM_LIST_TYPE(_)

#define	GNC_TYPE_SCHEDXACTION (gnc_schedxaction_get_type ())

#define	GNC_SCHEDXACTION(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GNC_TYPE_SCHEDXACTION, SchedXaction))

#define	GNC_SCHEDXACTION_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GNC_TYPE_SCHEDXACTION, SchedXactionClass))

#define	GNC_IS_SCHEDXACTION(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNC_TYPE_SCHEDXACTION))

#define	GNC_IS_SCHEDXACTION_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GNC_TYPE_SCHEDXACTION))

#define	GNC_SCHEDXACTION_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GNC_TYPE_SCHEDXACTION, SchedXactionClass))

#define	GNC_IS_SX(obj) GNC_IS_SCHEDXACTION(obj)

#define	GNC_SX(obj) GNC_SCHEDXACTION(obj)

#define	xaccSchedXactionSetGUID(X, G) qof_instance_set_guid(QOF_INSTANCE(X),(G))

#define	GNC_SX_SHARES "shares"

#define	GNC_SX_FREQ_SPEC "scheduled-frequency"

#define	GNC_SX_NAME "sched-xname"

#define	GNC_SX_START_DATE "sched-start-date"

#define	GNC_SX_LAST_DATE "sched-last-date"

#define	GNC_SX_NUM_OCCUR "sx-total-number"

#define	GNC_SX_REM_OCCUR "sx-remaining-num"

#define	xaccSchedXactionIsDirty(X) qof_instance_is_dirty (QOF_INSTANCE(X))

#define	xaccSchedXactionGetGUID(X) qof_entity_get_guid(QOF_INSTANCE(X))

#define	xaccSchedXactionGetSlots(X) qof_instance_get_slots(QOF_INSTANCE(X))

#define	GNC_TYPE_SCHEDXACTIONS (gnc_schedxactions_get_type ())

#define	GNC_SCHEDXACTIONS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GNC_TYPE_SCHEDXACTIONS, SchedXactions))

#define	GNC_SCHEDXACTIONS_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GNC_TYPE_SCHEDXACTIONS, SchedXactionsClass))

#define	GNC_IS_SCHEDXACTIONS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNC_TYPE_SCHEDXACTIONS))

#define	GNC_IS_SCHEDXACTIONS_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GNC_TYPE_SCHEDXACTIONS))

#define	GNC_SCHEDXACTIONS_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GNC_TYPE_SCHEDXACTIONS, SchedXactionsClass))

#define	GNC_IS_SXES(obj) GNC_IS_SCHEDXACTIONS(obj)

#define	GNC_SXES(obj) GNC_SCHEDXACTIONS(obj)

Typedefs
typedef struct _SchedXactionClass	SchedXactionClass

typedef struct _SchedXaction	SchedXaction

typedef struct _SXTmpStateData	SXTmpStateData

typedef struct xaccSchedXactionsDef	SchedXactions

typedef struct _SchedXactionsClass	SchedXactionsClass

Functions
GType	gnc_schedxaction_get_type (void)

SchedXaction *	xaccSchedXactionMalloc (QofBook *book)

void	sx_set_template_account (SchedXaction sx, Account account)

void	xaccSchedXactionDestroy (SchedXaction *sx)

void	gnc_sx_begin_edit (SchedXaction *sx)

void	gnc_sx_commit_edit (SchedXaction *sx)

GList *	gnc_sx_get_schedule (const SchedXaction *sx)

void	gnc_sx_set_schedule (SchedXaction sx, GList schedule)

gchar *	xaccSchedXactionGetName (const SchedXaction *sx)

void	xaccSchedXactionSetName (SchedXaction sx, const gchar newName)

const GDate *	xaccSchedXactionGetStartDate (const SchedXaction *sx)

void	xaccSchedXactionSetStartDate (SchedXaction sx, const GDate newStart)

int	xaccSchedXactionHasEndDate (const SchedXaction *sx)

const GDate *	xaccSchedXactionGetEndDate (const SchedXaction *sx)

void	xaccSchedXactionSetEndDate (SchedXaction sx, const GDate newEnd)

const GDate *	xaccSchedXactionGetLastOccurDate (const SchedXaction *sx)

void	xaccSchedXactionSetLastOccurDate (SchedXaction sx, const GDate newLastOccur)

gboolean	xaccSchedXactionHasOccurDef (const SchedXaction *sx)

gint	xaccSchedXactionGetNumOccur (const SchedXaction *sx)

void	xaccSchedXactionSetNumOccur (SchedXaction *sx, gint numNum)

gint	xaccSchedXactionGetRemOccur (const SchedXaction *sx)

void	xaccSchedXactionSetRemOccur (SchedXaction *sx, gint numRemain)

gint	gnc_sx_get_num_occur_daterange (const SchedXaction sx, const GDate start_date, const GDate *end_date)

gint	gnc_sx_get_instance_count (const SchedXaction sx, SXTmpStateData stateData)
	Get the instance count. More...

void	gnc_sx_set_instance_count (SchedXaction *sx, gint instanceNum)

GList *	xaccSchedXactionGetSplits (const SchedXaction *sx)

void	xaccSchedXactionSetSplits (SchedXaction sx, GList newSplits)

gboolean	xaccSchedXactionGetEnabled (const SchedXaction *sx)

void	xaccSchedXactionSetEnabled (SchedXaction *sx, gboolean newEnabled)

void	xaccSchedXactionGetAutoCreate (const SchedXaction sx, gboolean outAutoCreate, gboolean *outNotify)

void	xaccSchedXactionSetAutoCreate (SchedXaction *sx, gboolean newAutoCreate, gboolean newNotify)

gint	xaccSchedXactionGetAdvanceCreation (const SchedXaction *sx)

void	xaccSchedXactionSetAdvanceCreation (SchedXaction *sx, gint createDays)

gint	xaccSchedXactionGetAdvanceReminder (const SchedXaction *sx)

void	xaccSchedXactionSetAdvanceReminder (SchedXaction *sx, gint reminderDays)

GDate	xaccSchedXactionGetNextInstance (const SchedXaction sx, SXTmpStateData stateData)
	Returns the next occurrence of a scheduled transaction. More...

GDate	xaccSchedXactionGetInstanceAfter (const SchedXaction sx, GDate date, SXTmpStateData *stateData)

void	xaccSchedXactionSetTemplateTrans (SchedXaction sx, GList t_t_list, QofBook *book)
	Set the schedxaction's template transaction. More...

void	gnc_sx_add_defer_instance (SchedXaction sx, void deferStateData)
	Adds an instance to the deferred list of the SX. More...

void	gnc_sx_remove_defer_instance (SchedXaction sx, void deferStateData)
	Removes an instance from the deferred list. More...

GList *	gnc_sx_get_defer_instances (SchedXaction *sx)
	Returns the defer list from the SX. More...

gboolean	SXRegister (void)
	QOF registration.

GType	gnc_schedxactions_get_type (void)

SchedXactions *	gnc_book_get_schedxactions (QofBook *book)

void	gnc_sxes_add_sx (SchedXactions sxes, SchedXaction sx)

void	gnc_sxes_del_sx (SchedXactions sxes, SchedXaction sx)

Account *	gnc_book_get_template_root (const QofBook *book)

GList *	gnc_sx_get_sxes_referencing_account (QofBook book, Account acct)

Temporal state data.
These functions allow us to opaquely save the entire temporal state of ScheduledTransactions. This is used by the "since-last-run" dialog to store the initial state of SXes before modification ... if it later becomes necessary to revert an entire set of changes, we can 'revert' the SX without having to rollback all the individual state changes.
SXTmpStateData *	gnc_sx_create_temporal_state (const SchedXaction *sx)

void	gnc_sx_incr_temporal_state (const SchedXaction sx, SXTmpStateData stateData)

void	gnc_sx_destroy_temporal_state (SXTmpStateData *stateData)

SXTmpStateData *	gnc_sx_clone_temporal_state (SXTmpStateData *stateData)
	Allocates and returns a one-by-one copy of the given temporal state. More...

Detailed Description

Scheduled Transactions provide a framework for remembering information about a transactions that are set to occur in the future, either once or periodically.

Macro Definition Documentation

#define ENUM_LIST_TYPE ( _ )

Value:

_(INVALID,) \
        _(ONCE,) \
        _(DAILY,) \
        _(WEEKLY,)  \
        _(MONTHLY,) \
        _(MONTH_RELATIVE,) \
        _(COMPOSITE,)

Definition at line 34 of file FreqSpec.h.

#define xaccSchedXactionGetGUID ( X ) qof_entity_get_guid(QOF_INSTANCE(X))

Deprecated:

Definition at line 321 of file SchedXaction.h.

#define xaccSchedXactionGetSlots ( X ) qof_instance_get_slots(QOF_INSTANCE(X))

Deprecated:

Definition at line 323 of file SchedXaction.h.

#define xaccSchedXactionIsDirty ( X ) qof_instance_is_dirty (QOF_INSTANCE(X))

Deprecated:

Definition at line 319 of file SchedXaction.h.

Typedef Documentation

typedef struct _SXTmpStateData SXTmpStateData

Just the variable temporal bits from the SX structure.

Function Documentation

Account* gnc_book_get_template_root ( const QofBook * book )

Returns the template group from the book.

Definition at line 65 of file SX-book.c.

 {
     QofCollection *col;
     if (!book) return NULL;
     col = qof_book_get_collection (book, GNC_ID_SXTG);
     return gnc_collection_get_template_root (col);
 }

void gnc_sx_add_defer_instance	(	SchedXaction *	sx,
		void *	deferStateData
	)

Adds an instance to the deferred list of the SX.

Added instances are added in date-sorted order.

Adds an instance to the deferred list of the SX. Added instances are added in (date-)sorted order.

Definition at line 1201 of file SchedXaction.c.

 {
     sx->deferredList = g_list_insert_sorted( sx->deferredList,
                        deferStateData,
                        _temporal_state_data_cmp );
 }

SXTmpStateData* gnc_sx_clone_temporal_state ( SXTmpStateData * stateData )

Allocates and returns a one-by-one copy of the given temporal state.

The caller must destroy the returned object with gnc_sx_destroy_temporal_state() after usage.

Definition at line 1168 of file SchedXaction.c.

 {
     SXTmpStateData *toRet, *tsd;
     tsd = (SXTmpStateData*)stateData;
     toRet = g_memdup( tsd, sizeof( SXTmpStateData ) );
     return toRet;
 }

SXTmpStateData* gnc_sx_create_temporal_state ( const SchedXaction * sx )

Allocates a new SXTmpStateData object and fills it with the current state of the given sx.

Definition at line 1130 of file SchedXaction.c.

 {
     SXTmpStateData *toRet =
          g_new0( SXTmpStateData, 1 );
     if (g_date_valid (&(sx->last_date)))
          toRet->last_date       = sx->last_date;
     else
         g_date_set_dmy (&(toRet->last_date), 1, 1, 1970);
     toRet->num_occur_rem   = sx->num_occurances_remain;
     toRet->num_inst   = sx->instance_num;
     return toRet;
 }

void gnc_sx_destroy_temporal_state ( SXTmpStateData * stateData )

Frees the given stateDate object.

Definition at line 1162 of file SchedXaction.c.

 {
     g_free( (SXTmpStateData*)stateData );
 }

GList* gnc_sx_get_defer_instances ( SchedXaction * sx )

Returns the defer list from the SX.

This is a date-sorted state-data instance list. The list should not be modified by the caller; use the gnc_sx_{add,remove}_defer_instance() functions to modify the list.

Returns the defer list from the SX; this is a (date-)sorted temporal-state-data instance list. The list should not be modified by the caller; use the gnc_sx_{add,remove}_defer_instance() functions to modifiy the list.

Parameters

sx	Scheduled transaction

Returns: Defer list which must not be modified by the caller

Definition at line 1239 of file SchedXaction.c.

 {
     return sx->deferredList;
 }

gint gnc_sx_get_instance_count	(	const SchedXaction *	sx,
		SXTmpStateData *	stateData
	)

Get the instance count.

This is incremented by one for every created instance of the SX. Returns the instance num of the SX unless stateData is non-null, in which case it returns the instance num from the state data.

Parameters

sx	The instance whose state should be retrieved.
stateData	may be NULL.

Definition at line 1009 of file SchedXaction.c.

 {
     gint toRet = -1;
     SXTmpStateData *tsd;
 
     if ( stateData )
     {
         tsd = (SXTmpStateData*)stateData;
         toRet = tsd->num_inst;
     }
     else
     {
         toRet = sx->instance_num;
     }
 
     return toRet;
 }

gint gnc_sx_get_num_occur_daterange	(	const SchedXaction *	sx,
		const GDate *	start_date,
		const GDate *	end_date
	)

Calculates and returns the number of occurrences of the given SX in the given date range (inclusive).

Definition at line 726 of file SchedXaction.c.

 {
     gint result = 0;
     SXTmpStateData *tmpState;
     gboolean countFirstDate;
 
     /* SX still active? If not, return now. */
     if ((xaccSchedXactionHasOccurDef(sx)
             && xaccSchedXactionGetRemOccur(sx) <= 0)
             || (xaccSchedXactionHasEndDate(sx)
                 && g_date_compare(xaccSchedXactionGetEndDate(sx), start_date) < 0))
     {
         return result;
     }
 
     tmpState = gnc_sx_create_temporal_state (sx);
 
     /* Should we count the first valid date we encounter? Only if the
      * SX has not yet occurred so far, or if its last valid date was
      * before the start date. */
     countFirstDate = !g_date_valid(&tmpState->last_date)
                      || (g_date_compare(&tmpState->last_date, start_date) < 0);
 
     /* No valid date? SX has never occurred so far. */
     if (!g_date_valid(&tmpState->last_date))
     {
         /* SX has never occurred so far */
         gnc_sx_incr_temporal_state (sx, tmpState);
         if (xaccSchedXactionHasOccurDef(sx) && tmpState->num_occur_rem < 0)
         {
             gnc_sx_destroy_temporal_state (tmpState);
             return result;
         }
     }
 
     /* Increase the tmpState until we are in our interval of
      * interest. Only calculate anything if the sx hasn't already
      * ended. */
     while (g_date_compare(&tmpState->last_date, start_date) < 0)
     {
         gnc_sx_incr_temporal_state (sx, tmpState);
         if (xaccSchedXactionHasOccurDef(sx) && tmpState->num_occur_rem < 0)
         {
             gnc_sx_destroy_temporal_state (tmpState);
             return result;
         }
     }
 
     /* Now we are in our interval of interest. Increment the
      * occurrence date until we are beyond the end of our
      * interval. Make sure to check for invalid dates here: It means
      * the SX has ended. */
     while (g_date_valid(&tmpState->last_date)
             && (g_date_compare(&tmpState->last_date, end_date) <= 0)
             && (!xaccSchedXactionHasEndDate(sx)
                 || g_date_compare(&tmpState->last_date, xaccSchedXactionGetEndDate(sx)) <= 0)
             && (!xaccSchedXactionHasOccurDef(sx)
                 /* The >=0 (i.e. the ==) is important here, otherwise
                  * we miss the last valid occurrence of a SX which is
                  * limited by num_occur */
                 || tmpState->num_occur_rem >= 0))
     {
         ++result;
         gnc_sx_incr_temporal_state (sx, tmpState);
     }
 
     /* If the first valid date shouldn't be counted, decrease the
      * result number by one. */
     if (!countFirstDate && result > 0)
         --result;
 
     gnc_sx_destroy_temporal_state (tmpState);
     return result;
 }

GList* gnc_sx_get_schedule ( const SchedXaction * sx )

Returns: GList<Recurrence*>

Definition at line 559 of file SchedXaction.c.

 {
     return sx->schedule;
 }

GList* gnc_sx_get_sxes_referencing_account	(	QofBook *	book,
		Account *	acct
	)

Returns: The list of SXes which reference the given Account. Caller should free this list.

Definition at line 366 of file SX-book.c.

 {
     GList *rtn = NULL;
     const GncGUID *acct_guid = qof_entity_get_guid(QOF_INSTANCE(acct));
     GList *sx_list;
     SchedXactions *sxactions = gnc_book_get_schedxactions(book);
     g_return_val_if_fail( sxactions != NULL, rtn);
     for (sx_list = sxactions->sx_list; sx_list != NULL; sx_list = sx_list->next)
     {
         SchedXaction *sx = (SchedXaction*)sx_list->data;
         GList *splits = xaccSchedXactionGetSplits(sx);
         for (; splits != NULL; splits = splits->next)
         {
             Split *s = (Split*)splits->data;
             GncGUID *guid = NULL;
             qof_instance_get (QOF_INSTANCE (s), "sx-account", &guid, NULL);
             if (guid_equal(acct_guid, guid))
             {
                 rtn = g_list_append(rtn, sx);
             }
         }
     }
     return rtn;
 }

void gnc_sx_incr_temporal_state	(	const SchedXaction *	sx,
		SXTmpStateData *	stateData
	)

Calculates the next occurrence of the given SX and stores that occurence in the remporalStateDate. The SX is unchanged.

Definition at line 1144 of file SchedXaction.c.

 {
     GDate unused;
     SXTmpStateData *tsd = (SXTmpStateData*)stateData;
 
     g_date_clear( &unused, 1 );
     tsd->last_date =
         xaccSchedXactionGetInstanceAfter( sx,
                                           &unused,
                                           stateData );
     if ( xaccSchedXactionHasOccurDef( sx ) )
     {
         tsd->num_occur_rem -= 1;
     }
     tsd->num_inst += 1;
 }

void gnc_sx_remove_defer_instance	(	SchedXaction *	sx,
		void *	deferStateData
	)

Removes an instance from the deferred list.

If the instance is no longer useful; gnc_sx_destroy_temporal_state() it.

Removes an instance from the deferred list. If the instance is no longer useful; gnc_sx_destroy_temporal_state() it.

Definition at line 1213 of file SchedXaction.c.

 {
     GList *found_by_value;
 
     found_by_value = g_list_find_custom(
                          sx->deferredList, deferStateData, _temporal_state_data_cmp);
     if (found_by_value == NULL)
     {
         g_warning("unable to find deferred instance");
         return;
     }
 
     gnc_sx_destroy_temporal_state(found_by_value->data);
     sx->deferredList = g_list_delete_link(sx->deferredList, found_by_value);
 }

void gnc_sx_set_instance_count	(	SchedXaction *	sx,
		gint	instanceNum
	)

Sets the instance count to something other than the default. As the default is the incorrect value '0', callers should DTRT here.

Definition at line 1028 of file SchedXaction.c.

 {
     g_return_if_fail(sx);
     if (sx->instance_num == instance_num)
         return;
     gnc_sx_begin_edit(sx);
     sx->instance_num = instance_num;
     qof_instance_set_dirty(&sx->inst);
     gnc_sx_commit_edit(sx);
 }

void gnc_sx_set_schedule	(	SchedXaction *	sx,
		GList *	schedule
	)

Parameters

[in] schedule A GList<Recurrence*>

Definition at line 565 of file SchedXaction.c.

 {
     g_return_if_fail(sx);
     gnc_sx_begin_edit(sx);
     sx->schedule = schedule;
     qof_instance_set_dirty(&sx->inst);
     gnc_sx_commit_edit(sx);
 }

void xaccSchedXactionDestroy ( SchedXaction * sx )

Cleans up and frees a SchedXaction and its associated data.

Definition at line 473 of file SchedXaction.c.

 {
     qof_instance_set_destroying( QOF_INSTANCE(sx), TRUE );
     gnc_sx_commit_edit( sx );
 }

const GDate* xaccSchedXactionGetEndDate ( const SchedXaction * sx )

Returns invalid date when there is no end-date specified.

Definition at line 628 of file SchedXaction.c.

 {
     g_assert (sx);
     return &sx->end_date;
 }

GDate xaccSchedXactionGetNextInstance	(	const SchedXaction *	sx,
		SXTmpStateData *	stateData
	)

Returns the next occurrence of a scheduled transaction.

If the transaction hasn't occurred, then it's based off the start date. Otherwise, it's based off the last-occurrence date.

If state data is NULL, the current value of the SX is used for computation. Otherwise, the values in the state data are used. This allows the caller to correctly create a set of instances into the future for possible action without modifying the SX state until action is actually taken.

Definition at line 874 of file SchedXaction.c.

 {
     GDate    last_occur, next_occur, tmpDate;
 
     g_date_clear( &last_occur, 1 );
     g_date_clear( &next_occur, 1 );
     g_date_clear( &tmpDate, 1 );
 
     if ( g_date_valid( &sx->last_date ) )
     {
         last_occur = sx->last_date;
     }
 
     if ( stateData != NULL )
     {
         SXTmpStateData *tsd = (SXTmpStateData*)stateData;
         last_occur = tsd->last_date;
     }
 
     if ( g_date_valid( &sx->start_date ) )
     {
         if ( g_date_valid(&last_occur) )
         {
             last_occur =
                 ( g_date_compare( &last_occur,
                                   &sx->start_date ) > 0 ?
                   last_occur : sx->start_date );
         }
         else
         {
             /* Think about this for a second, and you realize that if the
              * start date is _today_, we need a last-occur date such that
              * the 'next instance' is after that date, and equal to the
              * start date... one day should be good.
              *
              * This only holds for the first instance [read: if the
              * last[-occur]_date is invalid] */
             last_occur = sx->start_date;
             g_date_subtract_days( &last_occur, 1 );
         }
     }
 
     recurrenceListNextInstance(sx->schedule, &last_occur, &next_occur);
 
     /* out-of-bounds check */
     if ( xaccSchedXactionHasEndDate( sx ) )
     {
         const GDate *end_date = xaccSchedXactionGetEndDate( sx );
         if ( g_date_compare( &next_occur, end_date ) > 0 )
         {
             g_debug("next_occur past end date");
             g_date_clear( &next_occur, 1 );
         }
     }
     else if ( xaccSchedXactionHasOccurDef( sx ) )
     {
         if ( stateData )
         {
             SXTmpStateData *tsd = (SXTmpStateData*)stateData;
             if ( tsd->num_occur_rem == 0 )
             {
                 g_debug("no more occurances remain");
                 g_date_clear( &next_occur, 1 );
             }
         }
         else
         {
             if ( sx->num_occurances_remain == 0 )
             {
                 g_date_clear( &next_occur, 1 );
             }
         }
     }
 
     return next_occur;
 }

gboolean xaccSchedXactionHasOccurDef ( const SchedXaction * sx )

Returns true if the scheduled transaction has a defined number of occurrences, false if not.

Definition at line 678 of file SchedXaction.c.

 {
     return ( xaccSchedXactionGetNumOccur( sx ) != 0 );
 }

SchedXaction* xaccSchedXactionMalloc ( QofBook * book )

Creates and initializes a scheduled transaction.

Definition at line 404 of file SchedXaction.c.

 {
     SchedXaction *sx;
 
     g_return_val_if_fail (book, NULL);
 
     sx = g_object_new(GNC_TYPE_SCHEDXACTION, NULL);
     xaccSchedXactionInit( sx, book );
     qof_event_gen( &sx->inst, QOF_EVENT_CREATE , NULL);
 
     return sx;
 }

void xaccSchedXactionSetEndDate	(	SchedXaction *	sx,
		const GDate *	newEnd
	)

Set to an invalid GDate to turn off 'end-date' definition.

Definition at line 635 of file SchedXaction.c.

 {
 /* Note that an invalid GDate IS a permissable value: It means that
  * the SX is to run "forever". See gnc_sxed_save_sx() and
  * schedXact_editor_populate() in dialog-sx-editor.c.
  */
     if (newEnd == NULL || g_date_compare( newEnd, &sx->start_date ) < 0 )
     {
         /* XXX: I reject the bad data - is this the right
          * thing to do <rgmerk>.
          * This warning is only human readable - the caller
          * doesn't know the call failed.  This is bad
          */
         g_critical("Bad End Date: Invalid or before Start Date");
         return;
     }
 
     gnc_sx_begin_edit(sx);
     sx->end_date = *newEnd;
     qof_instance_set_dirty(&sx->inst);
     gnc_sx_commit_edit(sx);
 }

void xaccSchedXactionSetName	(	SchedXaction *	sx,
		const gchar *	newName
	)

A copy of the name is made.

Definition at line 581 of file SchedXaction.c.

 {
     g_return_if_fail( newName != NULL );
     gnc_sx_begin_edit(sx);
     if ( sx->name != NULL )
     {
         g_free( sx->name );
         sx->name = NULL;
     }
     sx->name = g_strdup( newName );
     qof_instance_set_dirty(&sx->inst);
     gnc_sx_commit_edit(sx);
 }

void xaccSchedXactionSetNumOccur	(	SchedXaction *	sx,
		gint	numNum
	)

Set to '0' to turn off number-of-occurrences definition.

Definition at line 690 of file SchedXaction.c.

 {
     if (sx->num_occurances_total == new_num)
         return;
     gnc_sx_begin_edit(sx);
     sx->num_occurances_remain = sx->num_occurances_total = new_num;
     qof_instance_set_dirty(&sx->inst);
     gnc_sx_commit_edit(sx);
 }

void xaccSchedXactionSetTemplateTrans	(	SchedXaction *	sx,
		GList *	t_t_list,
		QofBook *	book
	)

Set the schedxaction's template transaction.

t_t_list is a glist of TTInfo's as defined in SX-ttinfo.h. The edit dialog doesn't use this mechanism; maybe it should.

Definition at line 1082 of file SchedXaction.c.

 {
     Transaction *new_trans;
     TTInfo *tti;
     TTSplitInfo *s_info;
     Split *new_split;
     GList *split_list;
 
     g_return_if_fail (book);
 
     /* delete any old transactions, if there are any */
     delete_template_trans( sx );
 
     for (; t_t_list != NULL; t_t_list = t_t_list->next)
     {
         tti = t_t_list->data;
 
         new_trans = xaccMallocTransaction(book);
 
         xaccTransBeginEdit(new_trans);
 
         xaccTransSetDescription(new_trans,
                                 gnc_ttinfo_get_description(tti));
 
         xaccTransSetDatePostedSecsNormalized(new_trans, gnc_time (NULL));
 
         /* Set tran-num with gnc_set_num_action which is the same as
          * xaccTransSetNum with these arguments */
         gnc_set_num_action(new_trans, NULL,
                         gnc_ttinfo_get_num(tti), NULL);
         xaccTransSetCurrency( new_trans,
                               gnc_ttinfo_get_currency(tti) );
 
         for (split_list = gnc_ttinfo_get_template_splits(tti);
                 split_list;
                 split_list = split_list->next)
         {
             s_info = split_list->data;
             new_split = pack_split_info(s_info, sx->template_acct,
                                         new_trans, book);
             xaccTransAppendSplit(new_trans, new_split);
         }
         xaccTransCommitEdit(new_trans);
     }
 }

Files

Data Structures

Macros

Typedefs

Functions

Temporal state data.

Detailed Description

Macro Definition Documentation

Typedef Documentation

Function Documentation