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

Post a Comment

Popular posts from this blog

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...
Post a Comment
Read more

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...
Post a Comment
Read more

How to remap graph properties?

Graph objects support both custom properties, which do not have special meanings, and standard properties, which may be used by some functions. When importing from formats such as GraphML, we usually get a result with custom properties. What is the simplest way to remap one property to another, e.g. to remap a custom property to a standard one so it can be used with various functions? Example: Let's get Zachary's karate club network with edge weights and vertex names from here: http://nexus.igraph.org/api/dataset_info?id=1&format=html g = Import[ "http://nexus.igraph.org/api/dataset?id=1&format=GraphML", {"ZIP", "karate.GraphML"}] I can remap "name" to VertexLabels and "weights" to EdgeWeight like this: sp[prop_][g_] := SetProperty[g, prop] g2 = g // sp[EdgeWeight -> (PropertyValue[{g, #}, "weight"] & /@ EdgeList[g])] // sp[VertexLabels -> (# -> PropertyValue[{g, #}, "name"]...
Post a Comment
Read more