Modified Cell Different Display

Question

Is there a way to show maybe a slightly different color, or change the cell bracketing color of a Mathematica cell when it has been modified?

Ideally it would be nice to follow the standard of using asterisks but cells don't really have names. Just to clarify a cell is modified when it has been edited but hasn't been run.

Code In Progress: This code basically is supposed to check to see if CellChangeTime changes on a set interval. It doesn't work currently but it is getting there.

Answer 1

To show a "modified" indicator, we should also choose an appropriate reference/origin from which it is tracked. A reasonable choice would either be the last notebook save or the time the cell was last evaluated. Since your intention is to track all modifications and not only modified + evaluated, I'll use the last save point as the reference.

The following is a proof of concept of a "cell modified" indicator. I'll discuss possible improvements and current limitations after the code:

1. Action when cell is modified

As mentioned above, I've chosen the time when the file was last saved (modification time on disk) as the reference point. The following function sets a cell's background to a light shade of gray if the cell modification time (as given by CellChangeTimes) is after the file modification time.

modifiedCell := With[{
    fileMod = "FileModificationTime" /. NotebookInformation[EvaluationNotebook[]], 
    cellMod = If[# != {}, Last@Flatten@#, -Infinity] &@CurrentValue[CellChangeTimes]},

    Switch[fileMod,
        "FileModificationTime", 
         None,

        _?NumericQ,
        If[fileMod < cellMod || cellMod === {},
            SetOptions[EvaluationCell[], Background -> GrayLevel[0.95]],
            SetOptions[EvaluationCell[], Background -> White]]
        ]
    ]

2. Action when notebook is saved

Given the choice of our reference time, it is necessary to reset the cell backgrounds (here, the "modified indicator") when the notebook is saved. The following function sets the background of all input cells in the notebook to White (you can also use your default background, if it's different or Background -> None).

notebookSaved := SetOptions[#, Background -> White] & /@ 
    Cells[EvaluationNotebook[], CellStyle -> "Input"]

Thanks to Michael for the tip re: using Cells directly instead of Cells + NotebookFind.

3. Setting up event handlers & piecing it together

All that remains is to set up appropriate event handlers — CellEventActions for when a cell is modified ("modified" here means a keypress in that cell) and NotebookEventActions for when the notebook is saved — and make the appropriate changes. I prefer to modify the stylesheet and add the changes to the "Input" style for the notebook. If you want other cells to also exhibit this behaviour, you'll have to add it yourself.

SetOptions[EvaluationNotebook[], {
    StyleDefinitions -> Notebook[{
        Cell[StyleData[StyleDefinitions -> "Default.nb"]], 
        Cell[StyleData["Input"], 
            CellEventActions -> {
                "KeyDown" :> modifiedCell,
                PassEventsDown -> True
            }, 
            Background -> GrayLevel[1]
        ]}, 
        Saveable -> True, StyleDefinitions -> "PrivateStylesheetFormatting.nb"
    ],
    NotebookEventActions -> {
        {"MenuCommand", "Save"} :> notebookSaved,
        PassEventsDown -> True
    }
}]

4. Current limitations

CellEventActions is triggered before the cell is actually modified. This means that the first change after a save point cannot trigger the change in background, because the CellChangeTimes still refers to the previous state (or in the case of a new cell, CellChangeTimes is empty). While this is a wee bit limiting, in practice, I've never had to make just 1 key press worth of change (without even pressing a modifier/arrow key in the process), so it might not be all that bad.

Answer 2

One idea is to burn in the input boxes into the cell when the cell is evaluated. Then, when the input boxes change, the background can be toggled indicating that the cell has changed. Here is a stylesheet approach that does this:

SetOptions[
    EvaluationNotebook[],
    StyleDefinitions -> Notebook[{
        Cell[StyleData[StyleDefinitions->"Default.nb"]],
        Cell[StyleData["Input"],
            CellEpilog :> With[
                {
                cell = EvaluationCell[],
                boxes = First @ NotebookRead @ EvaluationCell[],
                uuid = CurrentValue[ExpressionUUID]
                },
                SetOptions[
                    cell,
                    Background -> Dynamic[
                        If[First @ NotebookRead @ First @ Cells[ExpressionUUID -> uuid] == boxes,
                            None,
                            None, 
                            RGBColor[0, 0.5, 0, 0.1]
                        ]
                    ]
                ]
            ],
            CellFrameMargins->{{0, 0}, {0, 0}}
        ]
    }]
]

Here is an animation showing the highlighting in action:

Notice that the background turns light green when modified, but turns back to none when the edit returns the input cell back to its original form.

Answer 3

It would be nice to see if there is a way to use a regular cell box, but I am going to try a different technique instead. This example uses an InputField to display the content.

There are 2 issues currently 1) there appears to be no way to keep ShiftEnter from bubbling up and therefore producing a new cell 2) the formatter doesn't work.

DynamicModule[{color = RGBColor[1, 1, 1]}, EventHandler[
  InputField["a", String,
   Background -> Dynamic[color],
   ImageSize -> {Dynamic[(WindowSize /.
          Options[EvaluationNotebook[], WindowSize])[[1]]] - 112,
     Automatic}],
  {
   "KeyDown" :> (color = RGBColor[0.85`, 0.85`, 0.85`]),
   "ReturnKeyDown" :>
    FrontEndExecute[{NotebookWrite[EvaluationNotebook[], "\n",
       After]}],
   {"MenuCommand", "HandleShiftReturn"} :> {color = RGBColor[1, 1, 1]}
   }, PassEventsDown -> True
  ]
 ]