Skip to main content

front end - What are all the possible menu edits?


Note:


I've discovered the menus are more-or-less as customizable as one would like, although it is mildly annoying to do this. Simply write your own Menu expression and use FrontEndExecute@ResetMenusPacket[{expr}]. If someone more expert has a better way, though, I would really like to know it.


For those glancing through, here is a minimal example of a dynamically editable menu-symbol:


$FEMenuRoot=Import[];
$feStoredMenu = Automatic;

$FrontEndMenu := Replace[$feStoredMenu, Automatic -> $FEMenuRoot];
$FrontEndMenu /:
HoldPattern[Set[$FrontEndMenu, m : _Menu]] :=(
$feStoredMenu = m;
FrontEndExecute@ResetMenusPacket[{m}]
);
$FrontEndMenu /:
HoldPattern[
Set[$FrontEndMenu, Automatic]] :=
(

$feStoredMenu = Automatic;
FrontEndExecute@ResetMenusPacket[{Automatic}]);
$FrontEndMenu /:
HoldPattern[
Unset[$FrontEndMenu]] :=
($FrontEndMenu = Automatic;);

Then do something like:


$FrontEndMenu =
Menu["Mathematica",

{
Menu["DoopDoop", {
MenuItem["Copy", "Copy", MenuKey["C", Modifiers -> {"Command"}]],
MenuItem["Cut", "Cut", MenuKey["X", Modifiers -> {"Command"}]],
MenuItem["Paste", "Paste",
MenuKey["V", Modifiers -> {"Command"}]],
MenuItem["Save", "Save", MenuKey["S", Modifiers -> {"Command"}]],
MenuItem["Save as WL",
KernelExecute@
FrontEndTokenExecute["SaveRename",

{StringReplace[NotebookFileName[], ".nb" -> ".wl"], "Package"}
],
MenuKey["S", Modifiers -> {"Command", "Shift"}],
MenuEvaluator -> "Local",
Method -> "Queued"
],
MenuItem["Revert Menus",
KernelExecute[$FrontEndMenu =.],
MenuKey["R", Modifiers -> {"Command"}],
MenuEvaluator -> "Local"]

}],
Menu["", {
MenuItem["Musak",
KernelExecute@
SystemOpen@"https://www.youtube.com/watch?v=_lYx6dIKfos",
MenuEvaluator -> "Local"
]
}
]
}];


And you have menus you can play with.


Original Question:


So I've been playing with FrontEnd`AddMenuCommands recently and I wanted to figure out what all I could do with it.


There are a number of answers on this site to specific menu editing commands, but there is no general reference.


I've been able to figure out a bit from the source files, including making a useful reference graph of all the menus and submenus:


Menu graph


using the following code:


$MenuSetupTR = 
FileNameJoin@{$InstallationDirectory, "SystemFiles", "FrontEnd",

"TextResources", "Macintosh", "MenuSetup.tr"};
$MenuStringsTR =
FileNameJoin@{$InstallationDirectory, "SystemFiles", "FrontEnd",
"TextResources", "MenuStrings.tr"};
$menuStructure = Import@$MenuSetupTR;
$menuStrings = Import@$MenuStringsTR;
$menuNames =
Cases[$menuStructure, (MenuItem[__,
name_String?(StringContainsQ["Dialog"])] | Menu[name_, ___]) :>
name, ∞];

menuRules[Menu[name_, e_]] := Menu[name] -> menuRules@e;
menuRules[
ignore : (_String | _MenuItem | Delimiter | _AlternateItems)] :=
ignore;
SetAttributes[menuRules, Listable];
menuPart[menu_, name_] :=

FirstCase[menu, Menu[name, _], None, ∞];
menuPart[menu_, name1_, names__] :=


Fold[menuPart, menu, {name1, names}];
menuEdges[menu_] :=
ReplaceAll[
Cases[
DeleteCases[menuRules@menu,
Except[_Menu | _MenuItem |
Rule[_Menu, _] | _List | _String | _AlternateItems],
∞] //. {
Rule[m_, expr : Except[_Rule]] :> Thread[m -> expr],
Rule[m_Menu, Rule[subm_Menu, e_]] :> {m -> subm, subm -> e}

},
_Rule,
∞] // Flatten,
Rule -> DirectedEdge];
menuGraph[menu_] :=
With[{edges = menuEdges@menu},
Graph[
edges,
VertexShape -> {
Menu[n_] :> Graphics[Tooltip[{Hue[.1, .8, 1], Disk[]}, n]],

m_MenuItem :> Graphics[Tooltip[{Hue[.6, .8, 1], Disk[]}, m]],
e_AlternateItems :>
Graphics[Tooltip[{Hue[.4, .8, 1], Disk[]}, e]]
}
]
];
menuGraph@$menuStructure

But I was hoping someone might know which of these menus are actually editable and what I can add to them. There are also the dialogs, which I tried to scrape and found a few of and if someone could advise me on the use of these that would be a huge help too.


If this is too open ended, I'll refine the question, but in the meantime hopefully someone familiar with menu editing can help me out.




Playing around with this I was able to find a way to more or less edit all the menus, but we have to do it manually. It takes a bit of work to do so.


My idea was to use FrontEndExecute@ResetMenuPackets[{menu}] and build the menu manually.


I created a special $FrontEndMenu symbol which basically routes Set to that (plus some utility code and whatnot).


Then create Add, Insert, Drop, Take, etc. commands to manipulate a Menu expression.


The toplevel menu expression needs to look like Menu["Mathematica", {submenus}] as best I can tell (anything else I tried crashed the system).


Then just save the basic menu expression from the MenuSetup.tr file (import it in the System` context) and work with that.


Doing this I've been able to completely my menus however I like:


Menu rewrite


Two issues: I don't know if this will work outside of Mac and it prevents the use of the AddMenuComands token.



Hopefully there's also a simpler way to do this... if anyone has better ways though that'd be great, otherwise this'll do for customization I guess.




Comments

Popular posts from this blog

mathematical optimization - Minimizing using indices, error: Part::pkspec1: The expression cannot be used as a part specification

I want to use Minimize where the variables to minimize are indices pointing into an array. Here a MWE that hopefully shows what my problem is. vars = u@# & /@ Range[3]; cons = Flatten@ { Table[(u[j] != #) & /@ vars[[j + 1 ;; -1]], {j, 1, 3 - 1}], 1 vec1 = {1, 2, 3}; vec2 = {1, 2, 3}; Minimize[{Total@((vec1[[#]] - vec2[[u[#]]])^2 & /@ Range[1, 3]), cons}, vars, Integers] The error I get: Part::pkspec1: The expression u[1] cannot be used as a part specification. >> Answer Ok, it seems that one can get around Mathematica trying to evaluate vec2[[u[1]]] too early by using the function Indexed[vec2,u[1]] . The working MWE would then look like the following: vars = u@# & /@ Range[3]; cons = Flatten@{ Table[(u[j] != #) & /@ vars[[j + 1 ;; -1]], {j, 1, 3 - 1}], 1 vec1 = {1, 2, 3}; vec2 = {1, 2, 3}; NMinimize[ {Total@((vec1[[#]] - Indexed[vec2, u[#]])^2 & /@ R...

functions - Get leading series expansion term?

Given a function f[x] , I would like to have a function leadingSeries that returns just the leading term in the series around x=0 . For example: leadingSeries[(1/x + 2)/(4 + 1/x^2 + x)] x and leadingSeries[(1/x + 2 + (1 - 1/x^3)/4)/(4 + x)] -(1/(16 x^3)) Is there such a function in Mathematica? Or maybe one can implement it efficiently? EDIT I finally went with the following implementation, based on Carl Woll 's answer: lds[ex_,x_]:=( (ex/.x->(x+O[x]^2))/.SeriesData[U_,Z_,L_List,Mi_,Ma_,De_]:>SeriesData[U,Z,{L[[1]]},Mi,Mi+1,De]//Quiet//Normal) The advantage is, that this one also properly works with functions whose leading term is a constant: lds[Exp[x],x] 1 Answer Update 1 Updated to eliminate SeriesData and to not return additional terms Perhaps you could use: leadingSeries[expr_, x_] := Normal[expr /. x->(x+O[x]^2) /. a_List :> Take[a, 1]] Then for your examples: leadingSeries[(1/x + 2)/(4 + 1/x^2 + x), x] leadingSeries[Exp[x], x] leadingSeries[(1/x + 2 + (1 - 1/x...

What is and isn't a valid variable specification for Manipulate?

I have an expression whose terms have arguments (representing subscripts), like this: myExpr = A[0] + V[1,T] I would like to put it inside a Manipulate to see its value as I move around the parameters. (The goal is eventually to plot it wrt one of the variables inside.) However, Mathematica complains when I set V[1,T] as a manipulated variable: Manipulate[Evaluate[myExpr], {A[0], 0, 1}, {V[1, T], 0, 1}] (*Manipulate::vsform: Manipulate argument {V[1,T],0,1} does not have the correct form for a variable specification. >> *) As a workaround, if I get rid of the symbol T inside the argument, it works fine: Manipulate[ Evaluate[myExpr /. T -> 15], {A[0], 0, 1}, {V[1, 15], 0, 1}] Why this behavior? Can anyone point me to the documentation that says what counts as a valid variable? And is there a way to get Manpiulate to accept an expression with a symbolic argument as a variable? Investigations I've done so far: I tried using variableQ from this answer , but it says V[1...