Select Cells to End of Notebook

Question

I'd like to create a keyboard shortcut that will allow me to select all of the cells from the current cell until the end of the notebook, similar to how ShiftCtrlEnd functions when editing text in most Windows applications.

By editing KeyEventTranslations.tr, I've already created a shortcut using ShiftCtrlA that allows me to select the current cell (rather then pressing Ctrl. repeatedly). I'd like to then use another shortcut that would allow me to avoid having to hold down Shift and press ↓ over and over until I reach the bottom.

Any ideas?

I seem to recall that a simpler question, selecting multiple cells, had no forthcoming answer. I hope this proves possible but I'm doubtful. EDIT: docs for SelectionMove confirm: "SelectionMove can only select multiple cells as part of a CellGroup unit specification." — Mr.Wizard, Oct 30 '12 at 21:40
Welcome to Mathematica.SE! I suggest the following: 1) As you receive help, try to give it too, by answering questions in your area of expertise. 2) Read the FAQs! 3) When you see good Q&A, vote them up by clicking the gray triangles, because the credibility of the system is based on the reputation gained by users sharing their knowledge. ALSO, remember to accept the answer, if any, that solves your problem, by clicking the checkmark sign` — chris, Oct 31 '12 at 10:15

Rolf Mertig · Accepted Answer · 2012-10-31T19:58:15.707

Building on Albert's answer I added code such that Ctrl Shift End will select all cells downwards. Just execute this code in a notebook and restart Mathematica:

   mymenuitems="
         (* Select all cells downwards *)
         Item[KeyEvent[\"End\", Modifiers -> {Control, Shift}], 
         KernelExecute[
          Module[{ enb = EvaluationNotebook[],
                   tag = StringJoin[\"tmp\", ToString[Round[AbsoluteTime[]/$TimeUnit]]],editable 
                   },
                editable = ReplaceAll[Editable, Options[enb, Editable]];
                SetOptions[enb, Editable -> False];
                SelectionMove[enb, Next, Cell, AutoScroll -> False];
                MathLink`CallFrontEnd[FrontEnd`SelectionAddCellTags[enb, {tag}]];
                SelectionMove[enb, After, Notebook, AutoScroll -> False];
                SelectionMove[enb, Previous, Cell, AutoScroll -> False];
                While[FreeQ[ReplaceAll[CellTags,Options[NotebookSelection[]]], tag],
                      MathLink`CallFrontEnd[FrontEnd`SelectionAddCellTags[enb, {tag}]];
                      SelectionMove[enb, Previous, Cell, AutoScroll -> False]
                ];
                NotebookFind[enb, tag, All, CellTags, AutoScroll -> False];
                MathLink`CallFrontEnd[FrontEnd`SelectionRemoveCellTags[enb, {tag}]];
                SetOptions[enb, Editable -> editable]
            ]
            ], MenuEvaluator -> Automatic ]
            ";
    Quiet@CreateDirectory@FileNameJoin[{$UserBaseDirectory,"SystemFiles","FrontEnd","TextResources",$OperatingSystem}];
    mykeyeventtrans=FileNameJoin[{$UserBaseDirectory,"SystemFiles","FrontEnd","TextResources",$OperatingSystem,"KeyEventTranslations.tr"}];
    If[FileExistsQ[mykeyeventtrans],DeleteFile@mykeyeventtrans];
    CopyFile[FileNameJoin[{$InstallationDirectory,"SystemFiles","FrontEnd","TextResources",$OperatingSystem,"KeyEventTranslations.tr"}],mykeyeventtrans];
keytext=Import[mykeyeventtrans,"Text"];
mykeytext=StringReplace[keytext,"EventTranslations[{":>StringJoin["EventTranslations[{\n(* User defined *)\n",mymenuitems,",\n"]];
Export[mykeyeventtrans,mykeytext,"Text"];

I only tested this on Windows. No idea if it works on MacOSX and Linux.

Albert Retey · Answer 2 · 2012-10-31T16:14:50.863

I also don't know a straightforward way to do what you want, so Mr.Wizard could well be right. But there are workarounds as e.g. the following which is "abusing" CellTags. It is however somewhat hacky and not very fast and reliable and I'm not sure whether it is good enough for your every day use:

Module[{
  enb = EvaluationNotebook[],
  tag = StringJoin[
    RandomChoice[
     Join[CharacterRange["A", "Z"], CharacterRange["a", "z"], 
      CharacterRange["0", "9"]],
     30]
    ],
    editable
  },
 editable = Editable /. Options[enb,Editable];
 SetOptions[enb, Editable -> False];
 SelectionMove[enb, Next, Cell, AutoScroll -> False];
 MathLink`CallFrontEnd[FrontEnd`SelectionAddCellTags[enb, {tag}]];
 SelectionMove[enb, After, Notebook, AutoScroll -> False];
 SelectionMove[enb, Previous, Cell, AutoScroll -> False];
 While[FreeQ[CellTags /. Options[NotebookSelection[]], tag],
  MathLink`CallFrontEnd[FrontEnd`SelectionAddCellTags[enb, {tag}]];
  SelectionMove[enb, Previous, Cell, AutoScroll -> False];
  ];
 NotebookFind[enb, tag, All, CellTags, AutoScroll -> False];
 MathLink`CallFrontEnd[FrontEnd`SelectionRemoveCellTags[enb, {tag}]];
 SetOptions[EvaluationNotebook[], Editable -> editable]
 ]

It should be relatively clear what this does, nevertheless I think some remarks might be helpful:

I'm using a random tag to mark the cells to be selected (a common strategy to create global unique identifiers GUIDs), you could probably think of something smarter and e.g. check whether the tag you want to use is already present in the notebook to be on the really save side. I think it would, for almost all use cases, also be good enough to work with a constant unique identifier, though...
to temporarily add tags without destroying already existing ones, I'm using the undocumented frontend functionality SelectionAddCellTags and SelectionRemoveCellTags which I know from the excellent talk "The joy of Tagging" given by David Reiss at a Wolfram User Conference some years ago. You should be able to find the corresponding notebook in the web which is a good read if you try to do any kind of advanced notebook manipulating...
except for the random tag generation it should be possible to do this completely in the frontend which might be a good idea if you want it to be executed from a keyboard shortcut or button.
as suggested by Rolf Mertig I did set the notebook to not be editable while the code is running so that it should be relatively safe against user input.
there might well be other features, especially undocumented ones, which might let you do the same thing more reliable and faster, so don't accept this answer too early...

it is easy to secure against user input. Just add SetOptions[EvaluationNotebook[], Editable -> False]; at the beginning of the Module and SetOptions[EvaluationNotebook[], Editable -> True] at the end — Rolf Mertig, Oct 31 '12 at 10:32
I changed the tag to ToString @ Round @ AbsoluteTime[] . Or is there any good argument not to do so? — Rolf Mertig, Oct 31 '12 at 15:06
Why is SetOptions[EvaluationNotebook[], Editable -> False] the last thing to be evaluated? — acl, Oct 31 '12 at 15:47
@acl: because I didn't test it :-). Of course it should have been set to True. Actually it would be even better to set it to the value it had before we changed it, which I have now inserted... — Albert Retey, Oct 31 '12 at 16:15
@RolfMertig: I don't see any reason to not use ToString@Round@AbsoluteTime[]. We just need a string which is different from any of the CellTags that are contained in the notebook we are editing. Both of these approaches will be 'almost always' correct, which I think will be good enough. There are possibilities to get a list of existing CellTags as described in David's talk, so we could even crosscheck whether what we did choose really doesn't exist yet. And I think that such a check would even be very fast compared to the rest of the code... — Albert Retey, Oct 31 '12 at 16:20
You can speed this up a decent chunk by pushing all the FE calls into a single MathLink`CallFrontEnd. — b3m2a1, Jan 16 '18 at 16:31
@b3m2a1: thanks for mentioning that. Have you actually tried that? I actually wouldn't know how to do that for the While loop. Or were you just thinking about combining the code before/after the loop and in its body? — Albert Retey, Jan 17 '18 at 09:59

score 3 · Answer 3 · edited Apr 13 '17 at 12:55

In case this is helpful to anyone stumbling upon this thread this as I did, here is simpler code to select all cells from the end of a notebook to the current evaluation cell.

endAtID = First @ EvaluationCell[];
SelectionMove[EvaluationNotebook[], After, Notebook];
SelectionMove[EvaluationNotebook[], Previous, Cell];
While[
    SelectedCells[][[1, 1]] =!= endAtID,
    FrontEndTokenExecute[EvaluationNotebook[], "SelectPreviousLine"];
]

This can be modified to start from the cell containing the current insertion point, here is a button which will do this.

Button["press to select all cells from insertion point to end of notebook",
    SelectionMove[InputNotebook[], All, Cell];
    If[
        SelectedCells[InputNotebook[]] === {}, 
        SelectionMove[InputNotebook[], Next, Cell]
    ];
    endAtID = First @ SelectedCells[InputNotebook[]][[1]];
    SelectionMove[InputNotebook[], After, Notebook];
    SelectionMove[InputNotebook[], Previous, Cell];
    While[
        SelectedCells[InputNotebook[]][[1, 1]] =!= endAtID, 
        FrontEndTokenExecute[InputNotebook[], "SelectPreviousLine"];
    ]
]

The code inside the button above should work fine when triggered from a keyboard shortcut or palette button or wherever you want. To make it delete the selected cells, simply add

NotebookDelete[InputNotebook[]]

to the end of the code inside the button.

AMENDMENTS: To make the selection go from the insertion point to the end of the notebook, you can modify the code as such

Button["press to select all cells from insertion point to end of notebook",
    SelectionMove[InputNotebook[], After, Notebook];
    SelectionMove[InputNotebook[], Previous, Cell];
    endAtID = First@SelectedCells[InputNotebook[]][[1]];
    SelectionMove[EvaluationCell[], All, Cell];
    While[
        SelectedCells[InputNotebook[]][[-1, 1]] =!= endAtID, 
        FrontEndTokenExecute[InputNotebook[], "SelectNextLine"];
    ]
]

I like Albert Riley's suggestion in the comments to use FixedPoint so much I thought we should add it here

SelectionMove[InputNotebook[], All, Cell];
FixedPoint[
    (
        FrontEndTokenExecute[InputNotebook[], "SelectNextLine"];
        SelectedCells[InputNotebook[]]
    ) &,
    {}
]

very good find, turns out there is also a FrontEndToken "SelectNextLine" which would allow to select the rest of the notebook from top to bottom instead from bottom to top. Both seem to be quite useful, would you mind to share where you did find them? — Albert Retey, Aug 27 '15 at 15:38
Both would work indeed, you could move the selection to the end of the notebook and then select the previous cell and use a similar While loop. I found this front end token at the very end of the documentation for SelectionMove inside the "possible issues" subsection. — Kyle Keane, Aug 27 '15 at 15:46
Thanks for the information about the source, not exacty where one would actively search, but at least it's there:-). But isn't what you describe in the comment what already is in your answer and the "SelectNextLine" would allow to select the current cell and then extend to the end of the notebook? Something like: SelectionMove[InputNotebook[], All, Cell]; FixedPoint[(FrontEndTokenExecute[InputNotebook[], "SelectNextLine"]; SelectedCells[InputNotebook[]]) &,{}] — Albert Retey, Aug 27 '15 at 21:59
Yes my comment is the same concept, but it did need some refactoring. I added the code to the answer along with highlighting your intelligent use of FixedPoint — Kyle Keane, Aug 27 '15 at 23:22

score 2 · Answer 4 · answered Jan 16 '18 at 16:08

My take as I needed a solution I could just run in a cell or call from a pallete.

ClearAll[evaluateFromHere]
evaluateFromHere[
  HoldPattern[nb_NotebookObject : EvaluationNotebook[]]] :=
 Module[{},
  SelectionMove[nb, Previous, Cell, 1];
  If[
   SelectedCells[nb] == {},
   NotebookEvaluate[nb],
   Map[
     (SelectionMove[#, All, Cell];
       SelectionEvaluateCreateCell[nb];) &,
     NextCell[First@SelectedCells[nb], All]];
   ];
  ]

This is great! thanks for sharing – Jason B. Jan 16 '18 at 16:18 — Jason B., Jan 16 '18 at 16:18

Select Cells to End of Notebook

4 Answers4

Linked