Is there a way to require confirmation for execution of certain cells?

Question

Often I have Notebooks where I generate several images and export them into files. Now when I want to change one image, I'd like to just re-evaluate the complete notebook, however I generally do not want all images to be exported again, but only selected ones. For this, it would be useful if I could make some cells confirmation-only.

Ideally it would highlight the cell in question, but that's optional (I can just look at which cell is the first unevaluated). It should however make sure that the cell is visible (because Mathematica dialogs unfortunately tend to completely block the underlying notebook). It should ask me if I want to execute the cell, and if I say no, just skip it and continue at the next cell.

Is this possible, and if yes, how?

Bonus points if it doesn't trigger when doing Shift-Enter from within the cell in question (because in that case, it's obvious that I want it executed)

Answer 1

Perhaps there are better ways, but one I am aware of is by using CellEvaluationFunction option for a given cell. Here is code to generate some example cell with the behavior similar to what you presumably desire:

CellPrint[
   Cell[BoxData[RowBox[{"100", "!"}]], "Input", 
     CellEvaluationFunction -> 
       (Module[{res = ChoiceDialog["Evaluate this cell?"]}, 
          If[res, ToExpression[#]]] &)
   ]
]

A very informative account on CellEvaluationFunction, and the one I originally learned about it from, is this answer by @WReach.

EDIT

Here is a more elaborate version, which would also highlight the cell in question:

makeCell[] :=
 With[{tag = ToString[Unique[]] <> DateString[]},
    CellPrint[
      Cell[BoxData[RowBox[{"100", "!"}]], "Input", CellTags -> tag,
        CellEvaluationFunction ->
          ( 
             Module[{result = Null, thiscell, oldbackgr},
               NotebookLocate[tag];
               thiscell = NotebookSelection[];
               oldbackgr =  Background /. Options[thiscell] /. Background -> None;                   
               SetOptions[thiscell, Background -> LightGreen];
               If[ChoiceDialog["Evaluate this cell?"], result = ToExpression[#]];
               SetOptions[thiscell, Background -> oldbackgr];
               SelectionMove[EvaluationNotebook[], After, Cell];
               result
             ] &)
      ]]]

You can execute makeCell[] to see what this does.

Answer 2

For similar purposes using Button can be useful (in a non-sequential way):

images = ExampleData["TestImage"][[1 ;; 8]];
choice = ExampleData /@ images;
mods = ImageEffect[#, {"MotionBlur", 15}] & /@ choice;
buttons = 
  Button[Grid[{{"Export: " <> #[[1]]}, {Tooltip[#[[2]], 
         HoldForm[Export @@ #]]}}], Export @@ #] & /@ 
   MapIndexed[{images[[#2[[1]], 2]] <> "_mod.jpg", #} &, mods];
Grid[Partition[buttons, 4]]

For lots of different images you can do a nice Grid of these buttons. You can especially add useful information to the button label, in this example with a Tooltipshowing the to-be-executed code. It can take some care to preserve content across kernel sessions - With is your friend here (see How to inject an evaluated expression into a held expression? ).

Answer 3

I expanded the answer by @Leonid to restore the previous result if you cancel the evaluation and packaged the functionality into a cell style in my stylesheet for convenience. The cell expression for the stylesheet is pasted below.

This works in the cases I use often, but it has not been extensively tested. For example, it will not restore output in cases where multiple cells are generated during an evaluation of a single input cell. Also, only the last input of multiple input cells is displayed.

Cell[
    StyleData["ExportCell", StyleDefinitions -> StyleData["Input"]],
    CellEvaluationFunction->(
        Module[{result = Null, thiscell, oldbackgr, tag, oldresult,evalq, nb}, 

        (* find currently evaluating cell and change background *)
        nb=EvaluationNotebook[];
        SelectionMove[nb, All, EvaluationCell]; 
        thiscell = NotebookSelection[]; 
        oldbackgr = Replace[Background, Append[Options[thiscell], Background -> None]]; 
        SetOptions[thiscell, {Background -> LightGreen, CellTags -> (tag = StringJoin["Export", ToString[Unique[]]])}]; 
        NotebookLocate[tag]; 

        (* ask user whether to evaluate cell *)
        evalq = ChoiceDialog["Evaluate this cell?"];
        SetOptions[thiscell, Background -> oldbackgr];

        (* evaluate new result or reprint old result, as necessary *)
        If[evalq, 
            result = ToExpression[#],

            SelectionMove[nb,Next, Cell];
            oldresult=NotebookRead[nb];     

            (* basic check for case when there is no existing output, will miss cases with other outputs, e.g., Print commands *)
            If[oldresult[[2]]=="Output",
                NotebookWrite[nb,oldresult];,
                SelectionMove[nb,Previous,Cell];
            ];

        ]; 
        SelectionMove[nb,After,Cell];

        result
    ]& ),

    CellFrameLabels->{{None, "Export"}, {None, None}},
    MenuSortingValue->1500
]

EDIT:

Alternative check for output cell as suggested by @celtschk in comments is below. It's not an elegant implementation but it seems to work. However, this version may cause the input notebook to "blink" once as it autoscrolls rapidly back and forth in some cases where no output cell exists. Also, the input cursor location will not necessarily end up in the usual place since the front end normally moves it before evaluating any cells (actually, this is true of the previous version as well).

If[evalq, 
    result = ToExpression[#], 

   (* check if output cell exists *)
   SelectionMove[nb,All,CellGroup, AutoScroll->False];
   SelectionMove[nb,Before,CellGroup, AutoScroll->False];
   SelectionMove[nb,Next,Cell, AutoScroll->False];

   (* if input cell is first cell in a cell group *)
   If[tag===(ReplaceAll[CellTags, Options[NotebookSelection[nb],CellTags]]),
        SelectionMove[nb,All,CellGroup, AutoScroll->False];
        SelectionMove[nb,After,CellGroup, AutoScroll->False];
        SelectionMove[nb,Previous,Cell, AutoScroll->False];
        oldresult = NotebookRead[nb];
        (* if last cell in group is output cell *)
        If[Part[oldresult, 2] == "Output", 
            NotebookWrite[nb, oldresult]
        ],

        NotebookLocate[tag]
    ];
];