Attaching a file to a notebook

Question

Is there a way to attach a file into a notebook and open it later with, for instance, a double click (or another action button)?

In Mathematica windows version, the insert menu has the "object..." entry and I can indeed embed an object into my notebook. But then, I don't know how to exploit it in an attachment kind of way. For instance, in MS Word, if we "insert an object", we can then open it by double clicking its icon: windows opens the file with its predefined application.

For the purpose of the discussion, let’s suppose I want to attach a pdf file.

If this functionality isn't native on Mathematica, probably a technique based on this post can be used, with an intermediate step of export to a temporary folder, and then a Run kind of command...

I can also imagine a Dynamic interface, with a list of attached files (whose internal data/content is “kept” by a DynamicModule internal variable), and four buttons: add, delete, export and open. Since a Dynamic cell can be easily copied from a notebook to another, I could easily use this small embedding app on different notebooks.

There’s probably another button that would be useful: import. This would make the file content available, as a string, on a global context variable, or at least export the file to a temporary folder, and make its path available on a global context variable.

(if you go the "dynamic app" way, please consider, from the beginning, app conflicts if two apps are added to the same notebook; and a more tricky, or probably impossible task, to make some of its functionality work on the Player)

EDIT:

One answer that was deleted suggested SystemOpen for the "open" option, which seems a very good way of doing this part of the functionality

EDIT 2:

I was writing the following code when Sjoerd C. de Vries answered. My code is still only semi working but it gives an idea for a different interface approach.

DynamicModule[{id = 0, deleteFiles, selectEntry, addFile, 
  fPathTemp = Null, data = {}, 
  legend = Style[#, Bold] & /@ {"", "id", "Icon", "Name", "Type", 
     "Date Added", "Date Modified", "kB"}},
 Column[{
   Dynamic@Grid[Prepend[data[[All, Range[8]]], legend], Frame -> All],
   Row[{
     FileNameSetter[Dynamic[fPathTemp, (fPathTemp = #; addFile) &], 
      "OpenList", Appearance -> "+"],
     Dynamic@Button["-", deleteFiles, Enabled -> data != {}]

     }]
   }],
 Initialization :> (
   addFile := If[ListQ[fPathTemp],
     AppendTo[
        data, {False, id = id + 1, "", FileBaseName[#], 
         FileExtension[#], DateString[], DateString[FileDate[#]], 
         FileByteCount[#]/1000., 
         ExportString[Import[#, "String"], "Base64"]}] & /@ fPathTemp;
     fPathTemp = Null
     ];
   deleteFiles := (data = DeleteCases[data, _List?#[[1]] == True &])
   )
 ]

The "+" already works, but for the minus to work, it is missing a transformation of the False/True into a toggle interface (and then, obviously it is missing all other options...)

Answer 1

I believe the following program will do all you asked for. It will generate this little grid of buttons:

You can use the "Add file" button as many times as you want to add as many files you want. Those files are stored in the notebook that contains this button grid, so you can copy the grid to an empty notebook and use the files without the need to execute any code. The other buttons do what you intended. You get a dialog to determine the specific internal file to export, open or delete.

DynamicModule[{files, fileNames, selectedFile, fileChosen, fileName, 
  tempFile, fileSelectDialog, afButton, dfButton, efButton, ofButton},

 files = {};
 fileNames = {};

 fileSelectDialog[] :=
  If[fileNames === {},
   selectedFile = $Canceled, 
   (*else*)
   selectedFile = First@fileNames;
   DialogInput[
    Column[
     {
      TextCell["Select File:"],
      PopupMenu[Dynamic[selectedFile], fileNames], "", 
      Row[{CancelButton[], "  ", DefaultButton[DialogReturn@selectedFile]}]
      }
     ]
    ]
   ];

 afButton[] :=
  Button["Add file",
   fileChosen = SystemDialogInput["FileOpen"];
   If[fileChosen =!= $Canceled,
    fileName = FileNameTake@fileChosen;
    AppendTo[files, Compress@Import[fileChosen, "Byte"]];
    AppendTo[fileNames, fileName];
    ];,
   Method -> "Queued"
   ];

 dfButton[] :=
  Button["Delete file",
   fileChosen = fileSelectDialog[];
   If[fileChosen =!= $Canceled && fileNames != {},
    files = Delete[files, First@First@Position[fileNames, fileChosen]]; 
    fileNames = DeleteCases[fileNames, fileChosen, 1, 1], (*else*)
    DialogInput[
      DialogNotebook[{TextCell["Nothing to delete"], 
        Button["Proceed", DialogReturn[1]]}]];
    ];
   , Method -> "Queued"
   ];

 efButton[] :=
  Button["Export file",
   fileChosen = fileSelectDialog[];
   If[fileChosen =!= $Canceled && fileNames != {},
        fileName = SystemDialogInput["FileSave", fileChosen];
        If[fileName =!= $Canceled,
      Export[fileName, Uncompress@First@Pick[files, fileNames, fileChosen], "Byte"]
    ], 
    (*else*)
    DialogInput[
      DialogNotebook[{TextCell["Nothing to export"], 
        Button["Proceed", DialogReturn[]]}]];
    ];,
   Method -> "Queued"
   ];

 ofButton[] :=
  Button["Open file",
   fileChosen = fileSelectDialog[];
   If[fileChosen =!= $Canceled && fileNames != {},
        tempFile = FileNameJoin[{$TemporaryDirectory, fileChosen}];
    SystemOpen@
     Export[tempFile, Uncompress@First@Pick[files, fileNames, fileChosen], "Byte"],
    (*else*)
    DialogInput[
      DialogNotebook[{TextCell["Nothing to open"], 
        Button["Proceed", DialogReturn[]]}]];
    ];,
   Method -> "Queued"
   ];

 Manipulate[
  Grid[{{afButton[], dfButton[]}, {efButton[], ofButton[]}}],
  SaveDefinitions -> True, TrackedSymbols -> {}
  ]
 ]

Answer 2

This is a bit crude, but seems to work so far: First you get the data into your notebook file via filedata = Import["kitten.jpg", "RawData"];. With this raw data you now have, you create a Base64 representation:

base64data = ExportString[filedata, "Base64"]

(this is the same algorithm which is used in emails for representing binary data as alphanumeric-only characters - on the cost that it takes about 1.5x the size of the original file.) This data you then put in a cell and write myFileData = before it. Then mark the cell as initialisation cell.

Button["Write and open file",
   BinaryWrite["newkitten.jpg", 
     ToExpression[ImportString[myFileData, "Base64"]]]; 
   SystemOpen["newkitten.jpg"]
]

The button will then create a new file in the current working directory and open it. If anyone has a few suggestions how to streamline the process of getting the Base64 data permanently saved in the notebook, please let me know.