6

My simple first Palette is suppose to:

  • Append my packages Path to $Path

ActionMenu["test",{"The Simple Packages Path":> AppendTo[$Path, ToFileName[{NotebookDirectory[], "02 Simple Packages"}]]}]

  • Get my packages

ActionMenu["Load Packages", {"Get my package":> Get["myPackage`"]}]

  • Place on the selected input cell (or on a new input cell), a given input expression, containing different place holders.

OpenerView[{"my Package", Button["construct", Paste[StandardForm@Defer@construct[Placeholder["description"],Placeholder["another description"]]]]}]

The problem is that I keep getting "shadow" messages when I click on the "get my package" action menu item. And I'm sure I'm not double loading the package intentionally. When I click on "construct", it writes Global`construct["description","another description"]. But I'm sure I didn't define it before getting the package (I killed the kernel on my tests).

Do you know what is wrong?

(I use Get on my packages, instead of Needs, to ensure a clean start of the package context)

Also: do you know of a simpler way of doing the Paste[StandardForm@Defer... that ensures both that the expression being paste isn't evaluated and that it goes into an input cell, even when there's no cell selected?

Sjoerd C. de Vries
  • 16,122
  • 3
  • 42
  • 94
P. Fonseca
  • 549
  • 4
  • 12
  • I corrected a few errors in your brackets, which were probably due to copy-paste. There was a ' instead of a ` in your Get statement. I changed that too. Might that have been part of your problem? – Sjoerd C. de Vries Aug 11 '11 at 12:55
  • No. Actually I had problems with the copy paste, and also to show the text with a "code" format. Sorrey for the slight inconsistence of the code (it is actually a parcel of a code that has much more things in the middle, with Item, Style, etc...) – P. Fonseca Aug 11 '11 at 14:06

2 Answers2

6

Ok, it seems that your problem is due to the interplay between parsing and interface creation. What you would like in this case is to delay the parsing of package symbols in your interface - constructing code (package symbols that you use in button action functions), from the interface - creation time, until the "press button" time (assuming that by that time, the package has been loaded). Here is one way to do it:

Column[{ActionMenu["Load Packages",
   {"Get my package" :> Get["ANOVA`"]}],
   OpenerView[{"ANOVA", Button["construct",
       With[{sym = Symbol["ANOVA"]},
         Paste[StandardForm@Defer@sym[Placeholder["DATA"]]]]]}]}]

What we did here is to use With to inject the symbol into the code for the button function. But, at the time your interface code is parsed, we prevent the creation of the Global symbol with this name - this is what happens otherwise, and this is what causes your problem.

EDIT

If you know for sure that you only use symbols (functions) from packages, and not from the Global' context, here is a version that will be "protected" from this problem: it will Remove the generated symbol if its context turns out to be Global' - and thus pressing button before the package has been loaded would result merely in a warning message (I use the symbol package to attach the message to - should be replaced by whatever is the name of your interface - making function):

package::noload = "Please load the package containing symbol `1`";
Column[{ActionMenu["Load Packages",
  {"Get my package" :> Get["ANOVA`"]}],
   OpenerView[{"ANOVA", Button["construct",
      With[{sym = Symbol["ANOVA"]},
        If[Context[sym] === "Global`",
          Message[package::noload, Style[ToString[sym], Red]];
          Remove[sym];,
          (* else *)
          Paste[StandardForm@Defer@sym[Placeholder["DATA"]]]]]]}]}]
Leonid Shifrin
  • 22,449
  • 4
  • 68
  • 100
  • This SO question also seems relevant: http://stackoverflow.com/questions/4988427/accidental-shadowing-and-removedsymbol/. In particular, in my post there, I illustrate the same trick with using `Symbol` to delay parsing until run-time. – Leonid Shifrin Aug 11 '11 at 15:10
  • Understood the solutions. Thank you very much. What I don't understand is why the parsing of the interface needs to define the symbols on the Global context. The interface isn't supposed to process the code inside it until I press the button, why does it need to include all the symbols, not yet processed, inside the Global context? – P. Fonseca Aug 11 '11 at 15:14
  • 1
    @P.Fonseca This is the difference between parsing stage and evaluation stage. The code you enter in the FrontEnd, always gets parsed before it gets evaluated. Your code `Column[...]` does get evaluated - and parsed before that. However, some parts of it, notably the code for the button handler, do not evaluate during the interface-creation time (which is achieved by `HoldRest` attribute of `Button`). But, that code still gets parsed, and since the symbol - creation is a part of the parsing process, and no symbols with this name yet exist on the `$ContextPath`, a `Global` symbol is created. – Leonid Shifrin Aug 11 '11 at 15:20
  • @P.Fonseca To explain a bit more, *every* parsed symbol must belong to some context, and if the symbol does not exist by the parse-time in some package on the `$ContextPath`, it is created in the current working context (`"Global'"` here). Using `Symbol` is one way to delay the symbol-parsing from parse - time until run-time. Since we use it inside the button - handler code, it won't evaluate until we press the button. And since strings are trivially parsed to strings, no new symbols are created during the interface - construction time. – Leonid Shifrin Aug 11 '11 at 15:22
  • OK. What I wouldn't imagine is that the symbols need to be created in some contex at the parsing phase. I imagine there's a good practical reason for that... – P. Fonseca Aug 11 '11 at 15:28
  • @P.Fonseca The reason is simple. Mathematica is a symbolic system, and fully supports the code-is-data paradigm (that is, Mathematica code is written in Mathematica's own data structures (normal expressions), and can be programmatically manipulated). This is a very powerful capability, but the code must be fully parsed for it to work. So, if you want to delay the parsing of some part of code until run-time, then the only way I know to do it is to supply that code as a string, wrapped in `ToExpression` (or, `Symbol`, for symbol - parsing only), whose evaluation is delayed until run-time. – Leonid Shifrin Aug 11 '11 at 15:38
2

Well, I don't have your package, so for testing I changed the action menu to get the ANOVA package:

ActionMenu["Load Packages", {"Get my package" :> Get["ANOVA`"]}]

ANOVA[{{1, 1}, {1, 2}, {2, 4}, {2, 3}}] now works without a hitch. No complaints about shadowing. This suggests that the cause of your shadowing problem lies somewhere else. I noticed, though, that the word ANOVA stays blue. This will be related to the problem you reported here.

Community
  • 1
  • 1
Sjoerd C. de Vries
  • 16,122
  • 3
  • 42
  • 94
  • ActionMenu["Load Packages", {"Get my package" :> (Get["ANOVA`"]; Block[{nb}, nb = CreateDocument[ ExpressionCell[Defer[ToExpression[Names["ANOVA`*"]]], "Input"], Visible -> False]; SelectionMove[nb, All, Notebook]; SelectionEvaluate[nb]; NotebookDelete[nb]; ])}] – Rolf Mertig Aug 11 '11 at 13:42
  • Please try this one: Column[{ ActionMenu["Load Packages", {"Get my package" :> Get["ANOVA`"]}], OpenerView[{"ANOVA", Button["construct", Paste[StandardForm@Defer@ANOVA[Placeholder["DATA"]]]]}] }] – P. Fonseca Aug 11 '11 at 14:26
  • @P.Fonseca This gets me shadow message. The paste button pastes Global`ANOVA[placeholder] which is the wrong Context. – Sjoerd C. de Vries Aug 11 '11 at 15:57
  • That was exactly my problem. Leonid answer solved it. Thank you. – P. Fonseca Aug 11 '11 at 16:29