On Reverting Code that Mma Switches to Raw Input Form Back to Standard Form

Question

I experienced a similar issue to what is described in this post while editing formatted usage messages (that contained italics) in the declaration section of a package that I'm developing in the notebook front-end.

Question 1: Does anyone know what exactly causes Mma to convert code that contains formatted text to raw input form without explicitly being requested to do so by the user? Is this behavior part of a feature that several of us apparently do not fully understand ... or does it represent a bug in the parser that Wolfram acknowledges?

The solution described in the post linked above did not quite solve my problem because I need to evaluate the sequence of usage messages as part of setting up the package. I eventually found that

FrontEndExecute@FrontEnd`CellPrint["myFunction::usage=\"myFunction does ...\";"]

recovered the cell with usage messages displayed in standard input form exactly as I originally entered them (i.e. no explicit Styleboxes and escaping of quotes etc.).

In the process I reviewed the documentation on CellPrint and its FrontEnd-equivalent version. The main difference from what I could gather is that the former is handled by the kernel while the latter is processed solely in the FrontEnd. While experimenting with the two versions of CellPrint, I noticed the following:

CellPrint[Cell["a", "Input"]]

produces the cell expression

Cell["a", "Input"]

whereas

FrontEndExecute@FrontEnd`CellPrint["a"]

produces a BoxData-wrapped version of the above

Cell[BoxData["a"], "Input"].

One obvious consequence of this discrepancy is that the syntax highlighter colors the latter in blue but not the former.

Question 2: Why does the version of CellPrint evaluated in the kernel not wrap the input text in a BoxData structure too?

While my issue with the auto-conversion of usage messages to raw input form is now resolved I feel that my understanding from reading the documentation of how Mma parses and produces different formatting structures is still far from complete. Perhaps an answer here will shed additional light on this topic.

Answer 1

The simple answer is, if you want a string converted to StandardForm, you could wrap BoxData around it. E.g.,

CellPrint[Cell[BoxData["myFunction::usage=\"myFunction does ...\";"], "Input"]]

But, in general, I wouldn't structure this as a question of CellPrint vs. FrontEnd`CellPrint. FrontEnd`CellPrint is undocumented, and therefore there is no contract with the user that it will perform in any given way or that it will not change in the future. And, given that FrontEnd`CellPrint exists primarily as a vehicle for implementing CellPrint, I frankly can't even give any private assurances or documentation about its behavior that I would consider robust and future-proof.

Also, CellPrint may not be what you want in the first place. CellPrint is great for cells which become part of the output group. It generates "output-like" cells which will be automatically replaced upon the next re-evaluation. E.g., CellPrint[Cell[ToString[RandomReal[]], "Message"]]. You're creating an Input cell, which doesn't get regenerated because of the way that the cell groups are structured, but that begs the question...do you really want the Input cell to always appear (and be duplicated upon multiple evaluations) immediately after your code with CellPrint?

I would consider using NotebookWrite here (perhaps in combination with SelectionMove) here. NotebookWrite has some advantages I think you'll find useful:

• You can write anywhere you want to, even in a different notebook
• If you like, you can write code that deletes and replaces previously generated cells (using, e.g., NotebookFind and NotebookDelete)
• NotebookWrite allows you to write into cells in place rather than creating them from scratch.
• If you give NotebookWrite a string, the characters will be pasted in the same style as if the user had just begun typing those characters.

It should be mentioned that Paste has similar advantages to NotebookWrite.

The BoxData trick I mentioned before works with NotebookWrite, of course.

NotebookWrite[NotebookCreate[], BoxData["f[\"string\"]"]]

But it's not necessary to create a default, StandardForm Input cell.

NotebookWrite[NotebookCreate[], "f[\"string\"]"]

Does the same thing because this is what you would have gotten if you'd literally typed the characters of the string into the new notebook.