This software written in Tcl/Tk and pompously named e_menu provides a menu system bound to an edit / file managing session. A text editor / file manager with plugin or context facilities allows to use e_menu as "a plugin of plugins" that raises a whole environment of commands & menus around the editor / file manager.

e_menu combines the power of shell scripts with the power of Tcl/Tk.

The e_menu's scripts are simple for those knowing both the schell and Tcl scripting. These scripts are contained in menu files, divided into their own menu items.

The e_menu's menu files have .em extension and a simple structure, being edited on fly after choosing "Edit the menu" from e_menu's context menu. Any menu file may serve as a source of patterns for shell + Tcl scripting.

By now e_menu is implemented for alited editor, TKE editor, Kate editor, Geany IDE, Wing Python IDE and PyCharm IDE. Though the usage of e_menu is mostly independent on an editor / IDE, a few demonstrative details for alited, TKE, Kate, Geany, Wing and PyCharm are described below.

Also, e_menu can be used in file managers that provide scripting facilities.

The e_menu can be a mega-widget called from Tcl/Tk code as a modal / independent / dock / desktop window.

For Tclers, e_menu provides a context help on Tcl/Tk commands / keywords while editing a Tcl script.

The e_menu-3.0.mp4 is sort of demo just to glance at e_menu.

In more details, e_menu provides the following features:

• calling a context help for Tcl/Tk while editing a Tcl script (nay, any text containing Tcl)

• for faster response Tcl/Tk help pages can be made and called offline

• opening any number of menus containing any commands (programs) to run

• passing a selected text as %s wildcard to the menu commands to process

• using a lot of other wildcards in the menu commands, including %f (edited file name), %x (its extention), %d (its directory), %PD (its project's directory derived from %d)

• commands can be run by itself and by shell in console box

• commands can be run with or without waiting their completion

• internal command %E means “edit a file”
• internal command %B means “browse an internet link”
• internal command %M means “do a message”
• internal command %Q means “do a query“
• internal command %I means “enter a data that can be required by next commands“
• internal command %C means “execute a Tcl code“
• internal command %S means “execute OS command“
• internal command %IF means “conditional execution“

• a batch of multiple commands can be united under a single menu item which in turn can be multi-lined

• a menu item can include the whole shell script (even in two ways), so no need of disk files to perform it

• confirming messages or input dialogs (with entries, checkboxes, radiobuttons etc.) may provide data for commands

• the input data may be saved/restored between sessions

• a hierarchy of menus is provided

• a child menu can be called with or without closing its parent menu

• a child menu can be called with closing its parent and returning to the parent after closing the child

• menus can be called (or made afterwards) as 'stayed on the top of screen'

• menus can be called to stay at any desirable position with reasonable width

• dock and desktop type of e_menu can be used in Linux OS

• menu items can be bound to hotkeys F1-F9 (by default they are bound to 1-9a-zA-Z which makes maximum 61+3=64 items)

• menu items and their underlying commands can include counters of their calls (up to 10 counters per a menu)

• menu items and their underlying commands can be supplied with current date/time

• e_menu menus are independent applications and as such can be run independently on the editor

• however, s_menu.tcl can be used instead of e_menu.tcl to have a single window for all menus

• a stand-alone e_menu executable can be used instead of e_menu.tcl, providing an independence on Tcl/Tk installation

• e_menu.tcl can be used as a "mega-widget" from a Tcl/Tk script

• any menu item can be assigned to 'autorun' at start of e_menu (submenus including)

• commands that are invisible in menu may be assigned to 'autorun' (submenus including)

• Tcl command(s) can be assigned to 'autorun' at start of e_menu

• menus can be edited 'on fly' and then re-read

• when calling non-existent menu you are prompted to create it from a template; so you can create all menu system 'on fly'

• 'autorun' items and commands are also re-run when the menu is re-read

• menu items can be run repeatedly at intervals set in seconds

• e_menu can be started with a pause to delay its initialization

• e_menu neighboring applications can be killed with two keystrokes (sort of clearance)

• there are a lot of 'look and feel' options

• the options may be set at calling of e_menu and/or in [OPTIONS] section of a menu

• parent menu options are inherited by child menu and can be overridden by its [OPTIONS]

• as an easy exercise, Git, Fossil or Mercurial SCM support can be provided with e_menu

• encoding of menus is utf-8

We can include in our menus any commands that would process the selected text, as well as other relevant attributes: a current file's name, a file's directory, time/date, environment variables, a project's directory etc.

For example, having this e_menu menu

... and "package" selected in apave.tcl edited text, we can perform the following:

• HELP "package" - get a help on package command of Tcl

• EXEC "package" - execute a selection as a command

• SHELL "package" - execute a selection in a console box

• Run me (+ selection) - execute a current module with a selection as an argument(s) or execute a command from #ARGS: (#ARGS2: etc.), #RUNF: (#RUNF2: etc.) or #EXEC: (#EXEC2: etc.) comments

• Run Tcl {all selection} ... - run a selection as Tcl code in a console box

• Edit/create file "package" - edit (or create if absent) a file named after a selection

• Open directory "src" - open a current file's directory by file manager

• Open terminal in "src" - open a console box for the current file's directory

• Open in browser "package" site - go to an Internet site named after a selection

• Search in Firefox "package" - run Firefox's search machine for a selection

• Wikipedia for "package" - go to Wikipedia for a selection

• GoldenDict for "package" - go to GoldenDict for a selection

• Search All "package" in src - open a submenu to run grep on a current file's directory

• Backup of "apave.tcl" - create a backup of a current file (similar to Vim's backup)

• Commit "package" - make a SCM commit with "package" as a commit message (though editable)

• Differences of "apave.tcl" - show changes made to a current file since a last commit, with Fossil or Git GUI diff command

• Edit all *.tcl of 'current dir' - open all .tcl files of a current file's directory

• Fossil, Git, Hg - open a submenu with corresponding SCM commands

• Utils - open a submenu with miscellaneous commands and submenus

Now let's move to installing and customizing e_menu, as applied to Geany IDE.

Please try this:

1. If you do not have Tcl/Tk on your system, install it from www.tcl.tk. Linux users have it highly likely preinstalled. However, in Linux it may be necessary to install some packages or even to update Tcl to 8.6 version.

For example, in Debian Linux you might need the following packages:

• tcl8.6
• tcllib
• tk8.6
• tklib
• tcl-tls

• tkcon
• tcl-vfs
• tclx8.4

The Mac users should take e_menu "as is", because it hasn't been tested on Mac.

You can also download a stand-alone e_menu executable for Linux and Windows. It need no pre-installed Tcl/Tk.

2. Download and unpack e_menu.zip into the future e_menu directory, e.g. /home/me/UTILS/e_menu (for Windows it may be C:\Users\me\UTILS\e_menu).

3. Go to Geany's menu 'Edit/Settings', then to 'Tools' page and enter in the 'Context action' field:

  tclsh ~/UTILS/e_menu/e_menu.tcl m=menus/menu.em "s=%s"

  ~/UTILS/e_menu/s_menu m=menus/menu.em "s=%s"

  tclsh "~/UTILS/e_menu/e_menu.tcl" "s=%s" "md=~/UTILS/menus" m=menu.em "f=%d/%f" "d=%d" "PD=~/UTILS/e_menu_PD.txt" "TF=%f" "s1=%d" "z5=~" l=%l ts=1 c=0

The last call needs some explanation, but you can try it by guess. Remember only about the e_menu directories - here all those ~/UTILS/...

Now the context Tcl/Tk help should be available. While editing your Tcl/Tk script, select a Tcl/Tk command/keyword or simply place the caret on it and call “Context action” from popup menu. Incidentally being in Russia:-) you would see something like this:

where the first line calls Tcl/Tk help for “selection” (i.e. foreach, string, grid, panedwindow etc. - about 200 Tcl/Tk man pages and 26 pages of Tcl keywords from A.htm to Z.htm).

This screenshot would be different for official Geany. For example, you may see menu.em instead of a current file's name. The reason is that official Geany doesn't provide any of %f, %d etc. wildcards for its context command. Below this issue is considered, with advices how to fix it.

Note 1: In Geany's Edit/Settings you can map F1 key to the context action and call it with one keystroke.

Note 2: In alited the settings for e_menu are simplest, because alited is a natural editor to use e_menu, expanding its usage to its own tools.

The command to call e_menu is following:

tclsh e_menu.tcl [s=%s] [m=menufile] [options]

where any argument in brackets may be omitted, but one (or both) of s= or m= argument must be present. If not, e_menu puts out a message with its synopsis and ends up.

s= argument refers to a selected text, though it may be anything else to process as 'selection'. If s= is set, e_menu's menu includes the following three commands:

• HELP 'selection'
• EXEC 'selection'
• SHELL 'selection'

that mean:

• HELP calls Tcl/Tk context help for 'selection'
• EXEC executes 'selection' as a command/program by itself
• SHELL executes 'selection' as a command/program in console box

m= argument refers to a name of file containing a menu of commands. If m=menufile is set, e_menu adds to those three commands (if present) also the menufile's commands.

If s= argument is not set then the menufile's commands only are present in the menu. If both s= and m= are set then all commands are present in the menu, i.e. HELP/EXEC/SHELL and the menu file commands.

You can always pass a selection as s0= argument and get rid of those abominable 'HELP/EXEC/SHELL' forever.

A special -remain option may be useful when you want e_menu to stay on the screen. If -remain 1 is passed to e_menu, you can go through all menu hierarchy down and up. Thus, only with pressing Escape key on the root menu.em you close e_menu application.

At that you can call s_menu.tcl (or the stand-alone e_menu executable) instead of e_menu.tcl to have always a single menu's window on the screen. E.g., in Geany IDE you can set a context command as follows:

tclsh "~/UTILS/e_menu/s_menu.tcl" -remain 1 "md=~/UTILS/em/mnu" m=menu.em "s=%s" "f=%d/%f" "d=%d" "PD=~/UTILS/em/e_menu_PD.txt"

"~/UTILS/e_menu/s_menu" -remain 1 "md=~/UTILS/em/mnu" m=menu.em "s=%s" "f=%d/%f" "d=%d" "PD=~/UTILS/em/e_menu_PD.txt"

Other options of e_menu define a menu's look and behaviour and are described below, where:

• number means integer value
• “string” means text value

Note: It's strongly recommended to quote “string option”.

The options are:

Note: Options s0..s9, u0..u9, x*, y*, z* can include wildcards used in menu commands, e.g.:

  "s0= run #%i0 at %t2"
  "u0=_run_#%i0_at_%t2"

See also Processing wildcards below.

Most options described above can be set in [OPTIONS] section of a menu file, as e.g. in this menu:

  [OPTIONS]
  om=1
  o=0
  c=0
  fs=11
  w=52
  in=1.0
  h=/home/apl/DOC/www.tcl.tk/man/tcl8.6
  PD=/home/apl/PG/Tcl-Tk/projects/e_menu
  b=/usr/bin/chromium

  [MENU]
  ITEM = Firefox search for "%s"
  R: firefox -search "%s"

  ITEM = Wikipedia for "%s"
  R: %B https://en.wikipedia.org/w/index.php?cirrusUserTesting=classic-explorer-i&search=%+

  ITEM = Open/create file(s) "%s"
  R: %E %s

  ITEM = geany: edit all
  R: geany readme.md wiki.txt e_help.tcl e_menu.tcl

  SEP = 6
  ITEM = Git
  MW: m=%PN/git.em "u=%s" o=0 w=50

  ITEM = Tcl/Tk
  MW: m=%PN/tcltk.em w=20

  ITEM = Python
  MW: m=%PN/python.em w=40

  ITEM = Utils
  MW: m=%PN/utils.em

  ITEM = Links
  MW: m=%PN/links.em

  [HIDDEN]
  ITEM = 1. Stop work
  R: ?-33*60?-7*60:ah=2? audacious  /home/me/PG/breakon.wav
  ITEM = Arbeiten
  R: audacious /home/me/PG/breakoff.wav

The om= option is of particular weight. By default, the menu [OPTIONS] take priority over the options defined in a call string. This can be overridden by setting om=0 in the call string of e_menu - after that the call string options would have more priority than the menu [OPTIONS]. But all the same, the final decision is left to the menu that can reset the om= option to om=1 and override all previously set options of the call string or the parent menus.

Pay also attention to the in= option of [OPTIONS] section. If it is set in the form:
in=1.0
the e_menu will save and restore the last run position of menu.

Some options are intended rather for e_menu call string than for [OPTIONS] section. E.g. if you want to have a menu system 'project sensitive', do not include into [OPTIONS] such options as PD= (project directory) and PN= (project name). They are mostly for setting in a command line to call e_menu which is dynamic due to %d, %f etc. wildcards. Setting them in [OPTIONS] section you make them static.

And vice versa, if you want to have a specific menu iron bound to some project, include into its [OPTIONS] the PD=, PN= and om=1, as seen in the above example.

The last but not the least possibility for e_menu to receive options is an environment variable named E_MENU_OPTIONS.

It's mostly useful in command files run by shell. For example, in TKE, e_menu is run from main.tcl (a plugin's main module) which defines most options of it. To avoid modifying the main.tcl, we can define missing or redefine undesirable options in E_MENU_OPTIONS variable:

  #! /bin/bash
  # ...some commands...
  export E_MENU_OPTIONS="b=konqueror"
  tke &
  # ...other commands...

  export E_MENU_OPTIONS="99 b=konqueror"
  tke &

  export E_MENU_OPTIONS="b=konqueror 99 fs=10 cc=red"
  tke &

  "b=konqueror [...arguments set by main.tcl...] fs=10 cc=red"

Here are two examples of calling e_menu.

1.

  tclsh /home/me/e_menu/e_menu.tcl "s=%s" "m=menus/menu.em" \
  "h=/home/me/DOC/Tcl/tcl8.6" c=1 fs=11 \
  "PD=/home/me/PG/projects/myprj" b=/usr/bin/epiphany a=6,b

- this call of e_menu consists of:

• selected text of an editor (%s)
• menu file named menus/menu.em
• color scheme equaled to 1
• font size equaled to 11
• working directory equaled to /home/me/PG/projects/myprj
  (this would set PN=myprj as 'project name', used as %PN wildcard in commands)
• browser equaled to epiphany
• "h=/home/me/DOC/Tcl/tcl8.6" means that Tcl/Tk help is offline and located in /home/me/DOC/Tcl/tcl8.6
• a=6,b sets two menu items to run at start, having their menu hotkeys '6' and 'b'

The menu.em file is located in menus subdirectory of e_menu not related anyhow to the PD= which is a separate option of call and used as %PD wildcard in menu commands.

2.

This bash file runs Geany IDE and e_menu application positioned at right side of screen:

  #! /bin/bash

  DIR=/home/apl/PG/Tcl-Tk/projects/e_menu
  PROJECT=e_menu
  THEME="Preparing wiki"
  SUBJ=": calling e_menu"

  curdir=$PWD
  cd $DIR

  tclsh ~/.tke/e_menu/e_menu/e_menu.tcl \
  "s0=$PROJECT" "x0=$EDITOR" "x1=$THEME" "x2=$SUBJ" "b=/usr/bin/epiphany" "PD=$DIR" "d=$DIR" \
  md=~/.tke/plugins/e_menu/menus m=side.em g=+1484+25 t=1 o=0 w=16 pa=500 fs=10 ah=1,2 &

  geany readme.md wiki.txt e_help.tcl e_menu.tcl &

  cd $curdir

The menu is called as a topmost (t=1) independent application without ornament (o=0). Some options (PROJECT, THEME, SUBJ) are supplied to use in SCM commands as %s0, %x0 etc. wildcards. Geany IDE is run with project files as arguments.

The general structure of menu file is following:

  [OPTIONS]
  # ... options of e_menu call string
  # ...

  [MENU]
  ITEM = name1
  <marker> command1
  ITEM = name2
  <marker> command2

  SEP = N

  ITEM = name31
  <marker> ? command31
  ITEM = name32
  <marker> ?interval? command32

  SEP = N

  ITEM = name4
  <marker> command41
  <marker> command42
  <marker> command43

  # comments
  # ...

  [HIDDEN]
  1.
  ITEM = nameH1
  <marker> command_H1
  2.
  ITEM = nameH2
  <marker> command_H2
  # ...

where <marker> can be one of following:

• R/
• R: these ones run command and e_menu continues working

• RE/
• RE: these ones execute command and e_menu exits

• RW/
• RW: these ones run command and e_menu waits its completion

• S/
• S: these ones run command in console box and e_menu continues working

• SE/
• SE: these ones execute command in console box and e_menu exits

• SW/
• SW: these ones run command in console box and e_menu waits its completion

• MW/
• MW:
• M/
• M: these ones call a child menu and a parent continues working (note: MW type is the same as M)

• ME/
• ME: these ones call a child menu and close a parent

• I: Tcl commands (incl. the internal e_menu functions M, Q, S, T)

The [MENU] line may be omitted if menu commands go first. It's used after [OPTIONS] if co= argument is set in [OPTIONS] (see test1.em for example).

Markers with ”/“ are the same as with ”:“; the one and only difference is that in their corresponding commands all “\” are converted to ”/“. It's only for use in Windows and only for convenience, because e_menu being written in Tcl recognizes only ”/“ as a dividing slash of directory name.

You can manually replace "\" with "/" in Windows' pathes and use R: and S: markers.

The lines:

SEP = N

SEP = 4

Normally commands are run without catching their errors or warnings. But if you want to see return messages of a command, you may set ”?“ before the command as in command31 above.

Also, you can run a command repeatedly with interval in seconds set as ?interval? before the command (see command32 above and details below).

A menu item can contain several commands to run. To enable this you should place them under the same item name in successive lines. There must be strongly equal names for e_menu to identify them as a batch of commands united under a menu item. Any differences including spaces and empty lines are treated as a begin of new command or comment.

In Geany editor, pressing Ctrl+D doubles a current line or selected text.

In e_menu's internal editor, also there are hotkeys:
  - Ctrl+D to double a current line or selected text
  - Ctrl+Y to delete a current line
  - Ctrl+F to find first occurence of string
  - F3 to find next occurence of string
  - Ctrl+W to save and exit
(all of them are available from popup menu)

For example command4 (see above) contains in fact three successive commands united under ” name4 “.

[HIDDEN] section of menu file is of the same format as the previous visible one. Now it is used only to autorun commands that aren't visible in menu. For example command5 and command6 (see above) can be run at start of e_menu with ah=1,2 call argument. Hidden items are numerated with 1,2,..,9,a,b,… as well as visible ones.

One important command used in a batch of commands is 'cd'. It is inevitable if you have some program that, being altogether useful and good, nevertheless innocently assumes a current directory to be its 'own' one.

Comments are lines that begin with anything different from <marker>. Use for comments any commenting symbols you like.

A menu item name can begin with F1 through F9 which means a hotkey F1…F9 for this name. By default, items have hotkeys 1 through 9, a through z and A through Z. For example:

 ITEM = F1 Geany's help
 RE:%B file:///usr/share/doc/geany/html/index.html

- this would display e_menu that would display (after pressing F1) the help of Geany IDE and close.

It's useful feature if you mapped F1 to Geany context action - then double pressing F1 brings up Geany's help and closes e_menu.

An item marked with I: refers to some internals, namely the direct execution of Tcl commands. M, Q, S, T procedures of e_menu can be also used in I: items.

Important note: The I: item can be executed only standalone. It cannot participate in a batch of commands. So, the whole Tcl code should be presented in a one and only I: line to be executed. That said, you can use "\" as a line continuator and ";" as a command divider.

Here are few examples (note \$ and \n escaped for T):

ITEM = Xterm in "%PD"
I: S xterm -e bash

ITEM = Xterm in "%PD" (queried)
I: if {[Q "BASH" "Want to bash?"]} { cd "%PD"; exec xterm -e bash & }

ITEM = Console commands
I: M Three commands to be run in separate console boxes! ; \
  T dir \n \
  echo \$PWD \n \
  date

Item names and commands can include the following wildcards:

Wildcards of names and commands are processed in the following order:

• %PD

• %PN

• %s0, %s1, …, %s9

• %u0, %u1, …, %u9

• %+

• %qq

• %dd

• %ss

• %w, %m

• %s

• %u

• %t0, %t1, %t2, %t3

• %i0, %i1, …, %i9

• %x0, %x1, …, %x9

• %y0, %y1, …, %y9

• %z0, %z1, …, %z9

Probably, most obscure is the %I wildcard. It uses apaveObject input basically and allows to enter values of Entry, Checkbox, Radiobutton etc. The returned values can be multiple and are listed after ==.

Let's consider a few of examples of its usage.

1.

In this example from hg.em, a file name is entered manually or chosen from a file chooser.

 # entering a file name to view the file's changes since a last commit
 ITEM = kdiff3 of %F
 R: cd %PD
 R: %C if {![info exist ::FIL1] || $::FIL1==""} {set ::FIL1 "%f"}
 R: %I ques "KDIFF3" {filName {{File:} {} {-w 60}} {"$::FIL1"} lab} \
   -head "\n Enter/choose a file to kdiff3" -weight bold == ::FIL1
 R: hg extdiff -p kdiff3 "$::FIL1"

The dialog line by line:

• %C line initializes the variable for file name

• in %I line we run the input dialog, where each line excepting the last is terminated with " \" which is a line continuator

• ques stands for question icon (others are info, warn, err, "")

• KDIFF3 stands for a title of dialog window

• filName stands for a field name of entering/choosing file;
  it sets also the type of field (entry + file chooser)

• {File:} is the prompt

• {} stands for options of pack command

• {-w 60} stands for options of ttk::entry command, here a width

• {{File:} {} {-w 60}} are all options of entry field

• {"$::FIL1"} stands for passed value of the filName field
  (note that quotes are necessary as a file name can contain spaces)

• lab stands for ttk::label, it's last in the list, so its options are omitted;
  lab just separates File: from buttons, it's a pure ornamental detail

• the rest are options for heading message (-head, boldness)

• == ::FIL1 stands for variables receiving input (here only one)

This example produces the following picture:

2.

In this example from menu / utils / test1.em, more field types are used: Label, Entry, Radiobutton, Checkbutton, Combobox, Text, Listbox, Option Cascade, Tablelist:

 ITEM = Input dialog
 R: %C if {![info exist ::EN2]} {set ::EN2 ""; set ::V1 Exact}
 R: %C if {![info exist ::C1]}  {set ::C1 [set ::C2 0]}
 R: %C if {![info exist ::W1]}  {set ::W1 "in file"}
 R: \
  %I "" "TEST OF %I" { \
  ent1  {{   Find: }} {"$::EN1"} \
  ent2  {{Replace: }} {"$::EN2"} \
  labo  {{} {} {-t {\nOptions:} -font {-weight bold}}}  {} \
  radA  {{Match:   }} {"$::V1" {Exact} {Glob} {RE  }} \
  seh   {{} {} {}} {} \
  chb1  {{Match whole word only}} {$::C1} \
  chb2  {{Match case           }} {$::C2} \
  seh2  {} {} \
  v_    {} {} \
  cbx1  {{Where:   } {} {-state readonly}} {"$::W1" {in file} {in session} {in directory}} \
  tex1  {{Any text:} {} {-h 3 -w 50 -wrap word -tabnext lbx1}} {$::TEX} \
  lbx1  {{Related: } {} {-h 3}} {"$::LBX" {my Father} Mother Son Daughter Brother Sister Uncle Aunt Cousin {Big Brother} "Second cousin" "1000th cousin"} \
  opc1  {{Color:   }} {{$::OPT} {{color red green blue -- {{other colors} yellow magenta cyan \
      | #52CB2F #FFA500 #CB2F6A | #FFC0CB #90EE90 #8B6914}} \
      {hue dark medium light} -- {{opc widget example}} ok}} \
  tblSEL1  {{Table:   \n\nThe 'tbl' name\nis tblSEL* to\nreturn an item} {} {-h 4 -columns {16 {Name of widget} left \
    0 Type left 0 X right 0 Y right} }} {"$::TBL" {"but" "ttk::button" 1 1} \
    {"can" "canvas" 3 3} \
    {"chb" "ttk::checkbutton" 4 4} \
    {"cbx fco" "ttk::combobox" 23 2} \
    {"ent" "ttk::entry" 212 6}} \
  } \
  -head "Enter data:" -weight bold == ::EN1 ::EN2 ::V1 ::C1 ::C2 ::W1 ::TEX ::LBX ::OPT ::TBL

The dialog line by line:

• R: %C ... lines initialize the variables used in the dialog and commands afterwards. The dialog's variables can be also set in [OPTIONS] section, with two methods.

• ent1 and ent2 stand for ttk::entry fields to enter the Find and Replace values.

• labo field (ttk::label) is labeled as "Options:" (this may include \n to set blank rows), of bold font.

• radA stands for ttk::radiobutton;
  choices are listed after its value (quoted because of {RE } containing a space).

• seh is a horizontal separator.

• chb1 and chb2 are checkboxes.

• v_ is a vertical spacer.

• cbx1 is a combobox.

• tex1 is a text widget.

• lbx1 is a listbox.

• opc1 is an option cascade widget.

• tblSEL1 is a tablelist widget.

• == ::EN1 ::EN2 ::V1 ::C1 ::C2 ::W1 ::TEX ::LBX ::OPT ::TBL
  is a list of input variables; after "OK" they will get their input values.

Note: for more security it's recommended to use uppercased names of variables, i.e. ::EN1 instead of ::en1 etc. Though e_menu uses the global variables (a few), none of them is uppercased.

This example produces the following picture:

3.

In this example from hg.em, Entry, File Chooser and Text fields are used, the text widget being read-only (due to -ro 1 option).
This menu item allows to dig the file's differences down to a desirable level.

 ITEM = extdiff %F
 R: cd %d
 R: %C if {![info exist ::REV]}  {set ::REV -1}
 R: %C if {![info exist ::FIL]}  {set ::FIL "%f"}
 R: \
  %I "" "DIFFERENCES" { \
  v_0  {{} {-pady 7} {}} {} \
  ent1    {{Revision: } {} {}} {"$::REV"} \
  filName {{ of file: } {} {-w 65}} {"$::FIL"} \
  v_1  {{} {-pady 7} {}} {} seh {{} {} {}} {} v_2 {{} {} {}} {} \
  texc {{hg help:  } {} {-h 4 -w 52 -ro 1}} {A plain integer is treated \
as a revision number.\nNegative integers are treated as sequential offsets from the \
tip, with -1 denoting the tip, -2 denoting the revision prior to the tip, and so forth.} \
  } -head "\n Enter a revision (a prior commit's number):" -weight bold == ::REV ::FIL
 R: hg extdiff -r $::REV -p meld $::FIL

This example produces the following picture shot in TKE editor:

The Q command can be used in menus as a part of %C wildcard's content. The %Q wildcard uses the same syntax.

The %C Q and %Q both display warning dialogs.

Syntax:

%C Q ttl msg {typ okcancel} {icon warn} {defb OK} args
%Q ttl msg {typ okcancel} {icon warn} {defb OK} args

Using a1= call argument, you can warn a user about potential risks of an open menu, e.g.:

  MW: Dangerous MW: m=git2.em w= fs=50 c=5 "a1=if {![Q {DANGER!} \
  {These commands are dangerous\nand can set the world on fire! \
  \n\nContinue?}]} exit"

Here the Tcl commands are used to exit and close the dangerous menu possibly open by mistake. Q is a query with “head” and “message” that can contain wildcards like %s, %f. Q returns "false" if answered "Cancel" so that exit command closes the menu.

In a menu item, you can use %Q “head” “message”. It's the same query with the difference that e_menu stops executing the menu item after answering 'Cancel'. For example:

 ITEM = git reset --hard HEAD
  R: %Q "RESET" \
  "This cancels the last uncommitted changes and resets \
  \nto the last commited state!\n\nDo you want to RESET ? \
  \n\n(VERY LIKELY IT'S CANNOT BE UNDONE)"
  R: cd %PD
  S: git reset --hard HEAD

- here the cancelled commands are cd and git reset.

In the examples above, %C wildcard was used to initialize variables of input dialogs and commands.

If some initializing code is duplicated in a menu's items, it makes sense to move it into [OPTION] section, using %C wildcards in the same manner. This %C Tcl code would be executed at opening the menu. It may contain any number of Tcl commands devided with ";" or continued with "\".

For example, fossil.em uses this feature to discern two ways of its calling:

[OPTION]
%C if {{%F}=={*} && ![info exist ::EMENUFILE]} {set ::EMENUFILE "*"}
%C if {![info exist ::EMENUFILE]} {set ::EMENUFILE "%f"}

Also, if you want to have a set of variables used throughout the whole menu and saved (possibly) between the menu sessions, you'd find it convenient to define them in [OPTIONS] section. Specifically, the example of previous section can be rewritten this way:

ITEM = Differences of %F (hg extdiff)
  R: cd %d
  R: \
  %I "" "DIFFERENCES" { \
  v_0  {{} {-pady 7} {}} {} \
  ent1    {{Revision: } {} {}} {"$::REV"} \
  filName {{ of file: } {} {-w 61}} {"$::FIL"} \
  v_1  {{} {-pady 7} {}} {} seh {{} {} {}} {} v_2 {{} {} {}} {} \
  texc {{hg help:  } {} {-h 3 -w 52 -state disabled}} {A plain integer is treated \
as a revision number.\nNegative integers are treated as sequential offsets from the \
tip, with -1 denoting the tip, -2 denoting the revision prior to the tip, and so forth.} \
  } -head "\n Enter a revision (a prior commit's number):" -weight bold == ::REV ::FIL
  R: hg extdiff -r $::REV -p meld $::FIL
...
[OPTIONS]
::REV=-1
::FIL=%f
...

Thus, in [OPTIONS] you can set any variables that you may use everywhere in the menu's commands and input dialogs.

The variables' values are saved from one session to another, excluding those variables that contain % initial of wildcards. Above, the ::REV variable is initialized to -1 and saved for next menu sessions while ::FIL is always initialized with %f wildcard's value and saved only for a current menu session.

The e_menu detects the variables in [OPTIONS] by their glob template of "::*=*". You cannot use constructs sort of myVar=10. Instead, use ::MYVAR=10. This means that you are prompted to use global variables.

[OPTIONS]
::EMENUTMPFILE=%mn.tmp~

1. Nice way:

My Italian colleague Flavio had suggested the following usage of "S:" menu item: it can include the whole shell script!
It means no files on disk to perform bash scripts in e_menu!

The following example makes it clear:

  ITEM = Shell script
  S: ? \
  err=1; cd ~/FOSSIL; \
  # make a cycle till not found \n \
  while [ $err -eq 1 ]; \
    do repo=$(find *.fossil 2>/dev/null ); \
    err=$?; \
    if [ $err -eq 1 ]; then \
      if [ $(pwd) = '/' ]; then \
        echo "repo non esistente" ;break; \
      fi; \
      cd ../; \
    else \
      echo "$(pwd)/${repo}"; \
    fi; \
  done

This script finds all *.fossil files in a directory and echos their names.

This item of test1.em is available through "Menu / Utils / Test1 / Shell script". The actual item is somewhat different as for using co=; in [OPTIONS] to simplify things (";" and "; \" mean the same continuator of line).

Note:

• The "?" before the script allows to see any errors that would occur during its execution.

• The terminating "\" serves as a mark of line continuation.

• The "cd" command should go after first command if you make a script. Let it be any innocent command, sort of "tmp=0" (in this example it is "err=1").
  When e_menu comes into "cd " at beginning of any command, it considers the rest as a directory name (and swallows it silently if it's not a directory).

• Comments in scripts are terminated by "\n \" in order to run next commands.

A real life usage of this feature is available here: How to minimize the Mercurial SCM history of binary files.

2. Another nice way:

Perhaps, the preferable scripting way of e_menu would be through %#X wildcard where X may be any character unique for different dialogs of the menu.
It's well seen in test1.em, where the line:

ITEM = Shell script-2
S: %#s err=1; cd ~/FOSSIL

With this method, the previous script can be edited as a regular bash script:

# this script is run with %#s wildcard in test1.em
# it does the same as the previous "Shell script"

err=1
cd ~/FOSSIL
while [ $err -eq 1 ]
  do repo=$(find *.fossil 2>/dev/null )
  err=$?
  if [ $? -eq 1 ]; then
  if [ $(pwd) = '/' ]; then
    echo "repo non esistente" ; break
  fi
  cd ../
  else
  echo "$(pwd)/${repo}"
  fi
done

This item of test1.em is available through "Menu / Utils / Test1 / Shell script-2".
See also another example in grep.em available through "Menu / Search All / GREP TEMPLATE".

The macros allow to get rid of repetitions in .em files.

If some code is repeated in several places of menu, it would be a good candidate for a macro. For example, let our menu code be as follows:

 ITEM = fossil forget $::FILETAIL
 R: %I {} "FORGET FILE" { \
   v_ {{} {-pady 4} {}} {} \
   fil1 {{   File:} {} {-w 70}} {"$::EMENUFILE"} \
   } -head {\n This will forget a file in the Fossil repository. \
   \n Use wildcards to forget a few.} -hfg $::em::clrhotk -weight bold == ::EMENUFILE
 S: fossil forget $::EMENUFILE

Then, we can build %M1 macro like this:

%M1 TITLE %M1 MESSAGE %M1 COMMAND
%M1 R: %I {} "$TITLE" { \
   v_ {{} {-pady 4} {}} {} \
   fil1 {{   File:} {} {-w 70}} {"$::EMENUFILE"} \
   } -head {\n $MESSAGE} -hfg $::em::clrhotk -weight bold == ::EMENUFILE
%M1 S: fossil $COMMAND $::EMENUFILE

Thus, for forget, revert, remove, add commands, we can use the code:

 ITEM = fossil forget $::FILETAIL
 R: %M1 FOSSIL FORGET %M1 This will forget a file... %M1 forget

 ITEM = fossil revert $::FILETAIL
 R: %M1 FOSSIL REVERT %M1 This will revert a file... %M1 revert

 ITEM = fossil remove $::FILETAIL
 R: %M1 FOSSIL REMOVE %M1 This will remove a file... %M1 remove

 ITEM = fossil add    $::FILETAIL
 R: %M1 FOSSIL ADD %M1 This will add a file... %M1 add

The first %M1 TITLE %M1 MESSAGE %M1 COMMAND line sets the macro's parameters used in its body ($TITLE, $MESSAGE, $COMMAND). The corresponding arguments are set at the macro evaluation, e.g. this way: %M1 FOSSIL FORGET %M1 This will forget a file... %M1 forget.

This first line of macro may be empty (%M1), but it should go first in the macro code, all the same.

Other lines of macro should contain:

• macro name of %M? form (%M0 through %M9, %Ma through %Mz, %MA through %MZ, %M~, %M!, %M@, %M# and so on)
• type of line (R:, S:, RE:, SW: and so on)
• content of line (any stuff used in menu's lines, including "\" as a continuation mark)

1.

e_menu being written in Tcl requires ”/“ in pathnames. So, in order to avoid manual converting “\” to ”/“, items are marked with “R/” instead of “R:”, “RW/” instead of “RW:” and so on. It's used only in Windows.

Here is an example:

  # menu for e_menu

   ITEM = GoldenDict
   R/ "C:\Program Files (x86)\GoldenDict\GoldenDict.exe"
   ITEM = FVdict for "%s"
   R/ cd C:\Program Files (x86)\FVdict
   RW/ fvdict.exe %s
   ITEM = Tclsh "samples/%s.tcl"
   R/ tclsh "C:\PG\Tcl-Tk\examples\Proj01\%s"
   ITEM = Tkcon
   S/ tkcon

   ITEM = Firefox search for "%s"
   R: firefox -search "%s"
   ITEM = Wikipedia for "%s"
   R: %B https://en.wikipedia.org/w/index.php?cirrusUserTesting=classic-explorer-i&search=%+

   ITEM = Git menu
   MW/ "m=menus\gitmenu.txt" o=0 "PD=%d" "s=%s"

A menu item FVdict for ”%s“ consists of two commands: the first one sets current directory of command, the second executes it (and wait its completion).

Notice that the command 'cd' does not require quoting directory path, because it's executed by e_menu that adds missing quotes. Other commands with spaced pathnames need quoting them.

Also notice how WWW searches are called for Firefox search machine and for Wikipedia: "%+" is the same as "%s" with spaces replaced by "+".

A last item calls and then waits for a git menu that is in the example below.

2.

Most commands in this menu need changing to a project's directory, so 'cd' is first used in a batch of commands.

The command batches contain mixed 'R' and 'S' markers which means that their commands are executed by itself and by shell in console box.

The wildcard %s refers to the editor's selection. The wildcard %dd is the same as %s but it's used to get rid of special symbols as ”, $, %, {, }, [, ], <, >, *.

The wildcard %M shows a message.

The wildcard %Q shows a query with 'title' and 'query text'. Being answered 'Cancel' it cancels the execution of batch.

In %Q command you should use edging double quotes and internal single quotes in a title and a message. Symbol \n stands for an empty line.

  # git menu for e_menu

  ITEM = nautilus command
  R: %M Now the nautilus file manager should go to %PD directory.
  R: nautilus "%PD"

  ITEM = git status
  S: cd %PD
  S: git status

  ITEM = git gui
  R: cd %PD
  R: git gui

  ITEM = git add *
  S: cd %PD
  S: git add *

  ITEM = git commit -m "%dd"
  S: cd %PD
  R: %Q "Committing changes" "Commit with message\n\n'%dd' ?"
  S: git commit -m "%dd"

  ITEM = git commit -am "%s"
  S: cd %PD
  R: %Q "Committing changes" "Add and commit with message\n\n'%s' ?"
  S: git commit -am "%s"

  ITEM = git log "--since=1 day ago"
  S: cd %PD
  S: git log "--since=1 day ago"

  ITEM = git log -p "--since=1 day ago"
  R: cd %PD
  S: git log -p "--since=1 day ago"

  ITEM = Others
  MW: m=menus/git2.em w=40

The following example illustrates step by step how to create and use e_menu in Windows. Linux version is mostly the same and even more simple than Windows'.

It's assumed that you had installed Tcl/Tk and e_menu software. If not, refer to Introduction.

It's also assumed in the next sections that e_menu has been unpacked into C:\UTILS\e_menu directory. The example deals with Geany IDE.

To start from scratch, the Geany's context command would be as follows:

tclsh C:\UTILS\e_menu\e_menu.tcl "s=%s"

Try e_menu now. Set the caret on a word of your text edited in Geany IDE. You may also select a piece of text. Call 'Context action' from popup menu or with a hotkey mapped to it.

You should see the following:

(in this example 'Step 1' was selected in Geany editor).

If you see it, e_menu works OK. Well, if you are not Tcler then skipping the rest of this step would not harm you badly.

The first line of the picture above means calling a context help on Tcl/Tk command or keyword you had selected.

The help is online. You can tune it to be offline for faster response and zero of Internet. To do it try this:

• include the h= argument into Geany context action:

 tclsh C:\UTILS\e_menu\e_menu.tcl "s=%s" h=C:\DOC\www.tcl.tk\man\tcl8.6

• download the Tcl/Tk help to C:\DOC directory with commands:

  md C:\DOC

  cd C:\DOC

  wget -r -k -l 2 -p --accept-regex=.+/man/tcl8\.6.+ https://www.tcl.tk/man/tcl8.6/

Now the offline help should be ready to call. If not, check the version of your wget utility.

Retry Tcl/Tk help calling. Select in your text (or place the caret on), for example, package and call the editor's context menu. You should see something like:

Click on the first item and you would see the Tcl/Tk help on package.

Let's try and create a simple menu of 2 commands that would be available from Geany's context.

The menu file will be C:\UTILS\e_menu\menus\test.em. We shall use commands that process the editor's selected text to:

• seek the selected internet pages
• view the selected words in a dictionary

Fill the C:\UTILS\e_menu\menus\test.em with the following:

  ITEM = Firefox search for "%s"
  R/ ""C:\Program Files (x86)\Mozilla Firefox\firefox.exe" -search "%s"

  ITEM = Dictionary FVdict for "%s"
  RW/ cd C:\Program Files (x86)\FVdict
  RW/ fvdict.exe "%s"

(Here a fvdict dictionary is used. It's one of many similar dictionaries that accept a word as input argument and put out a translation of it. This one is English-Russian available at https://aplsimple.github.io/ru).

After that include the menu file into the call string of Geany's context, for example:

 tclsh C:\UTILS\e_menu\e_menu.tcl "s=%s" h=C:\DOC\www.tcl.tk\man\tcl8.6 m=menus/test.em

NOTE: if you dislike to have the HELP/EXEC/SHELL commands in your menu though the context would be desirable, you can use:

• “s0=%s” instead of “s=%s” in Geany's context command
• %s0 instead of %s in menu commands

For example, you can write Geany's context command as:

 tclsh C:\UTILS\e_menu\e_menu.tcl "s0=%s" m=menus/test.em

… and test.em as:

  ITEM = Firefox search for "%s0"
  R/ "C:\Program Files (x86)\Mozilla Firefox\firefox.exe" -search "%s0"

  ITEM = Dictionary FVdict for "%s0"
  RW/ cd C:\Program Files (x86)\FVdict
  RW/ fvdict.exe "%s0"

… and then you should see:

… instead of:

Try and seek the selected “Firefox” in WWW. Click the item named Firefox search for “Firefox” and you would see something like:

The e_menu's menus are hierarchical. You can include a submenu into any menu with the following e.g.:

  MW/ Test4 menu MW/ "m=test4.em" o=0

NOTE: here “o=0” option means that the submenu doesn't contain the header i.e. those awful messages “Use arrow… (or press…”. Also notice that s0= option is passed to the submenu (as well as the other options of parent menu), and only m= and o= options were overridden for the child menu. In the example below the PD= option is added as well. The header is useful for mouse moving of menu, btw.

Let's create a submenu test4.em located at C:\UTILS\e_menu\menus.

However, at the beginning we should write it in the parent menu test.em so:

• test.em:

  ITEM = Firefox search for "%s"
  R/ "C:\Program Files (x86)\Mozilla Firefox\firefox.exe" -search "%s"

  ITEM = Dictionary FVdict for "%s"
  RW/ cd C:\Program Files (x86)\FVdict
  RW/ fvdict.exe %s

  ITEM = Test4 menu
  MW/ "m=test4.em" "PD=C:\UTILS\e_menu\" o=0

After that if you clicked on the menu item, e_menu would offer to create the menu file. Answer “OK” and you'll get the following menu template:

  ITEM = nam1
  R: prog

  ITEM = nam2
  S: comm

  ITEM = nam3
  M: m=e_menu/nam3.em

The template contains three most common types of records to fill a menu.

Now let's fill our submenu with the following:

• test4.em:

  ITEM = echo %%s0 is %s0
  SW: echo %%s0 is %s0

  ITEM = echo %%PD is %PD
  SW: echo %%PD is %PD

  ITEM = git init
  R: %Q "Init GIT" "Are you sure to init git in\n\n%PD ?"
  R: cd %PD
  S: git init

  ITEM = git status
  R: cd %PD
  S: git status

  ITEM = git gui
  R: cd %PD
  R: git gui

  ITEM = git add *
  R: cd %PD
  S: git add *

  ITEM = git commit -am '%s'
  R: %Q "Committing changes" "Do you really want to commit with message\n'%s' ?"
  R: cd %PD
  S: git commit -am "%s"

Call the Geany context action again. You should see the following:

After choosing “Test4 menu” you'll see the new submenu:

In the submenu you can play with its items. Notice that some git commands would require a confirmation. Also notice how a working directory is passed to the child menu with “PD=” argument and then used in its commands as “%PD” wildcard.

First items only echo the options passed to e_menu. Echos are useful for debugging btw. Other items refer to GIT system so that they would be working if you had installed GIT.

The e_menu usage is rather standard for menus.

The following keys take actions of menu:

• Down or Tab to select a next item

• Up or Shift+Tab to select a previous item

• Space, Enter, Return to execute a selected item

• hotkeys 1,2,3..a,b.. to execute items quickly

• hotkeys F1, F2, .. F9 (if set) to execute items quickly

• Esc to close a menu

The following hot keys can be also used:

• Ctrl+P to change a project's directory, set/view a menu's color scheme and geometry

• Ctrl+T to switch on/off 'stay on the top' mode

• Ctrl+E to edit a current menu file

• Ctrl+R to re-read a current menu file and restart its 'autorun' list

• Ctrl+D to delete other e_menu applications (sort of clearance)

• Ctrl+Right to increase a menu's width

• Ctrl+Left to decrease a menu's width

If not redefined in the menu, F1 calls 'About' dialog where 'Help' button displays this wiki.

You can use the right and the left arrow keys for calling and closing a submenu respectively.

The popup menu will appear after your right click. You can select the described actions from it.

Any menu can be dragged on the screen if it's grasped by the top space.

The internal editor of e_menu provides the popup menu and the following hot keys:

• Ctrl+D to double a current line or a selected text

• Ctrl+Y to delete a current line

• Alt+Up to move a current line or a selected text up

• Alt+Down to move a current line or a selected text down

• Ctrl+F to find a first occurence of string

• F3 to find a next occurence of string

• Ctrl+Z to undo changes

• Ctrl+Shift+Z to redo changes

• Ctrl+W to save and exit

• Esc to exit without saving

After saving a menu or executing an edited command (grep, wget), the edit position is saved in [OPTIONS] so that it's restored at editing next time.

Some editors and IDE provide a full set of data for e_menu, while others only partly.

In general, any editor providing a sort of %f (and %s as desirable) wildcard for its external tools or plugins can take advantage of e_menu.

For example, Pluma, a text editor for MATE Desktop Environment, provides %f only. So, we can set in its menu Service / Manage External Tools... a command like this:

#!/bin/sh
tclsh "~/PG/e_menu/e_menu.tcl" "md=~/DATA/e_menu/menus" m=menu.em "f=$PLUMA_CURRENT_DOCUMENT_PATH" "PD=~/PG/e_menu_PD.txt" s=? h=~/DOC/www.tcl.tk/man/tcl8.6

Almost the same settings are available in Gedit, a text editor for GNOME Desktop Environment. In its External Tools, we can set a command like this:

#!/bin/sh
tclsh "~/PG/e_menu/e_menu.tcl" "md=~/DATA/e_menu/menus" m=menu.em "f=$GEDIT_CURRENT_DOCUMENT_PATH" "PD=~/PG/e_menu_PD.txt" s=? h=~/DOC/www.tcl.tk/man/tcl8.6

Of course, all pathes in the commands are specific for a machine.

The alited is a natural editor for integrating with e_menu. After all, both have been written by the same guy, me:)

Thus, the description of alited is the best guide for using e_menu in it.

Here is presented alited's screenshot only, where the top toolbar contains e_menu by itself and other its tools:

For e_menu to be used in TKE editor, the TKE should be installed from .tgz archive (most likely, you would not be able to run e_menu from the stand-alone tke.exe in Windows). Then you should unpack the archive file and run tclsh install.tcl under the directory of unpacked TKE. If some Tcl packages were absent, the installer would notice it with its error messages. In those cases you should install the required package(s) and repeat tclsh install.tcl for TKE.

The main feature of e_menu in TKE is its implementation as TKE plugin. As a result, almost all of environment details presented by Tcl/Tk and TKE can be passed to e_menu as arguments (including s0-s9, x0-x9, y0-y9, z0-z9).

As for now available, the additional facilities include:

• executing the current Tcl script in tclsh (with selected text as arguments of script)
• executing the selected Tcl code in tclsh
• z6= argument equaling to a 'left' edited file (on TKE file bar); used to compare with current file
• z7= argument equaling to a 'right' edited file (on TKE file bar); used to compare with current file
• ts=1 argument when there is 'a real selected text' (not just a caret set on a word)

The last option is related to special comments in current text:

#ARGS0: arguments
#ARGS1: arguments-1
#ARGS2: arguments-2
...
#ARGS99: arguments-99

The first found of such strings is used as arguments for calling 'Run me' of menu.em.
Others can be disabled for example this way:

#-ARGS0: -k 1 test/test12ini
#-ARGS1: -mode exact -backup 0 tasks/mulster-tke
#ARGS10: -mode exact -backup 0 tasks/mulster-geany

tclsh mulster.tcl -mode exact -backup 0 tasks/mulster-geany

If there is a real selection in TKE text, then ts=1 and %AR value equals to the selection. Thus, #ARGS doesn't work at the real selection of text.

The "ts=" option of e_menu can be also used with Wing IDE, because of its cool API for plugin scripts.

There isn't a way to define "ts=" in PyCharm, Geany and Kate, thus the %AR wildcard of their e_menu can get only a #ARGS value.

TKE's e_menu provides TF=tempfile argument where tempfile is a name of temporary file containing all of selected text. It can be used (as %TF wildcard) by those commands that need the whole selection 'as is'. In TKE, s=%s argument supplies only first non-empty string of selection.

Another specific feature of TKE's e_menu is an option available in "Edit / Preferences / Plugins". This option switches on / off saving a current file before running the plugin.

For KDE Applications 19.12 release, it's possible to use External Tools in Kate editor. The tools may include e_menu as well.

The e_menu in Kate is customized this way:

• open Settings/ Configure Kate.../ External Tools
• add "e_menu" item to External tools
• enter the data for e_menu, mostly tclsh and e_menu.tcl arguments

The arguments for tclsh may be as follows:

~/PG/e_menu/e_menu.tcl md=menus m=menu.em c=12 "f=%{Document:FilePath}" "s=%{Document:Selection:Text}" ln=%{Document:Cursor:Line}+1 cn=%{Document:Cursor:Column}+1

Other settings are seen in the picture below:

In Settings / Configure Keyboard Shortcuts, the shortcut for e_menu may be customized.

And below is a picture of e_menu called from Kate:

The main problem of using e_menu in Geany is that the official Geany doesn't provide %f and %d wildcards for the context command. As we've seen, these wildcards are of main interest for e_menu. See for example https://github.com/geany/geany/issues/1836.

Another issue of Geany is that its context command is disabled when %s (selected text) is empty. It's rather serious restriction for using e_menu. What if we want simply to view SCM status of project? For this action we need no selected text at all.

At last, Geany might save a current file before running the context command (if it includes %f, %d and other file-related wildcards), as it behaves before running Compile/Build/Run.

Shortly, our good old official Geany needs to be unofficialized a bit.

There is already a version of Geany with the proposed modification. Download its code by this link. Still, this version may be obsolete a little.

As for new versions of Geany, you can do the following:

• Clone Geany with:

  git clone git://github.com/geany/geany.git geany

  as recommended in: https://www.geany.org/Download/Git

• Download a tool to modify Geany's code, by the link mulster.zip.

• Replace all files in mulster/tasks/geany/src directory of unpacked mulster.zip with the Geany clone's ones (i.e. from geany/src).

• Run in console, under mulster directory, the following command:

  tclsh mulster.tcl -mode exact -backup 0 tasks/mulster-geany
  

  All replacements should be done, i.e. you should see all "Replacement #1: 1 done".
  If any not done, the console messages notify about this. In such case, the whole quest is cancelled :((

• Copy all mulstered files from mulster/tasks/geany/mulstered back to geany/src).

# possibly, "make distclean" is not mandatory for the last Geany versions
make distclean
./autogen.sh
./configure
# or possibly
./configure --disable-html-docs
make
sudo make install

  autoconf
  intltool
  libtool
  libglib2.0-dev
  libgtk-3-dev