Compacting Entries

If you use JXCirrus Diary to manage large projects, especially where you log lots of time sessions, then there is a chance that you might have a pretty big project file.   That is OK - The system can cope with it.   But... You might notice that it starts to get a bit slow to save and load the data.

It might be the case that some large task trees are actually finished with.   You might wish to keep the time records, but you don't need the entire tree.   Pressing the Compact will do the following:
  1. Collapse all of the tasks below that into the task you have selected.
  2. Save all of the records of time spent into this task.
  3. Save any details from the tasks into this one.
  4. Remove all dependencies from the task (this speeds up recalculating).

Preventing Compacting

If you have a task that you want kept during a compact operation, then edit the task, and go to the Properties page, and tick the check-box marked "Preserve During Compact".   Selecting this check box means that everything under this task will be compacted, but it will be preserved.

You might use this if you use JXCirrus for issue tracking.   You might want all of the issue sub-tasks to be merged, but the issue itself kept.

It is also possible to set a whole class of tasks to be preserved using object specs (Diary++ version only).    To do this, set the $<Preserve> variable to "1" for a spec, and that spec will be preserved during compact operations.   See Specs under the Preserve variable.

When Compacting Doesn't Happen

There are three things that prevent an entry from being compacted:

  1. The entry is marked to be preserved.
  2. In object specs - If this is a mandatory child entry of another spec, then it cannot be compacted.
  3. The entry is a task, and it is not complete.

NOTE: When a task won't be compacted, all of the tasks at the same level in the tree will be preserved - This is so that the duration value still adds up to the same amount.   See the example below...
NOTE: Even if a task is preserved, compacting will still clean up dependencies between tasks.

An Example

Before compacting...  The entries that are underlined are marked as "Preserve" (U and M).

A + S + T
+ +
  + + U + V
+ + W
+
 + B + G + H + I
+ +
  +   + K + V
+ + L
+
+ C
+
+ D + M + R
+
     + E + N
+ + W
+
 + O + P
+ F + Q
+ G

After compacting...
A + S + T
+ +
  + + U
+
 + B
+
+ C
+
+ D + M
+
     + E
+
 + O