Kahakai

SUBMITTED BY: Guest

DATE: June 2, 2014, 2:16 p.m.

FORMAT: Text only

SIZE: 29.1 kB

Raw Download

HITS: 5895

Report
  1. NAME
  2. Kahakai - an X11 window manager with multi-language embedded scripting
  5. SYNOPSIS
  6. kahakai [--display DISPLAYNAME] [--rcfile CONFIGFILE] [--stylefile STYLEFILE] [--menufile MENUFILE] [--usage] [--help] [--version]
  9. DESCRIPTION
  11. Kahakai is a fork of the Waimea window manager, with the goal of allowing as much internal customization as possible. Kahakai uses SWIG to provide wrappers that allow high-level scripting languages to access the internals of the core of the window manager, which is written in C++.
  14. OPTIONS
  16. --display DISPLAYNAME
  17. X server to contact
  19. --rcfile CONFIGFILE
  20. Use the alternate CONFIGFILE instead of ~/.kahakai/config and /usr/share/kahakai/config.
  22. --stylefile STYLEFILE
  23. Use the alternate STYLEFILE instead of /usr/share/kahakai/styles/Default. This overrides styleFile resource.
  25. --menufile MENUFILE
  26. Use the alternate MENUFILE instead of /usr/share/kahakai/menu This overrides menuFile resource.
  28. --usage
  29. Display brief usage message
  31. --help
  32. Show full help message
  34. --version
  35. Output version information and exit
  38. CONFIG FILE
  39. When starting, Kahakai looks for a .kahakai/config resource file in the users home directory. If file doesn't exist, Kahakai falls back to /usr/share/kahakai/config, the system wide configuration file. To force Kahakai to read a different configuration file use --rcfile switch. Below is a list of configuration options that Kahakai understands.
  41. screenMask: List of screen numbers
  42. Whitespace separated list of screens that Kahakai should manage. If you for example want Kahakai to handle only screen .0 and screen .2, then list of screen numbers should be: 0 2
  44. scriptDir: Dirpath
  45. Path to alternate scripts directory instead of /usr/share/kahakai/scripts. scriptDir is used execution of dynamic menu scripts.
  47. doubleClickInterval: Integer
  48. Adjust the delay (in milliseconds) between mouse clicks for Kahakai to consider it a double click. Default value is 300.
  50. When running Kahakai on display with multiple screens the screen0 key in the following configuration options can also be screen1, 2 etc. for any appropriate screen.
  52. screen0.styleFile: Filepath
  53. Path to alternate STYLEFILE instead of /usr/share/kahakai/styles/Default.
  55. screen0.menuFile: Filepath
  56. Path to alternate MENUFILE instead of /usr/share/kahakai/menu.
  58. screen0.numberOfDesktops: Integer
  59. This tells Kahakai how many virtual desktops we should use. Default value is 4.
  61. screen0.desktopNames: List of desktop names
  62. A comma separated list of desktop names.
  64. screen0.doubleBufferedText: Boolean
  65. Tells Kahakai to use double buffered text drawing method. Removes text flickering and requires far less text redrawing. Faster in most cases. But be aware, then using flat solid textures one double buffered text redraw is more expensive than one single buffered one. Default value is True.
  67. screen0.lazyTransparency: Boolean
  68. Tells Kahakai to use lazy redrawing of transparent textures. When enabled, Kahakai only redraws transparent textures at end of move functions. Default value is False.
  70. screen0.colorsPerChannel: Integer
  71. This tells Kahakai how many colors to take from the X server on pseudocolor displays. A channel would be red, green, or blue. Kahakai will allocate this variable ^ 3 colors and make them always available. Value must be between 2 and 6. When you run Kahakai on an 8-bit display, you must set this resource to 4. Default value is 4.
  73. screen0.cacheMax: Integer
  74. This tells Kahakai how much memory (in KB) it may use to store cached pixmaps on the X server. If your machine runs short of memory, you may lower this value. Default value is 200.
  76. screen0.imageDither: Boolean
  77. Tells Kahakai to dither images on none TrueColor screens. Default value is True.
  79. screen0.virtualSize: IntegerxInteger
  80. Tells Kahakai what virtual desktop size to use. Example: 3x3 will set the virtual desktop size to three times screen height in virtual height and three times screen width in virtual width. Default value is 3x3.
  82. screen0.menuStacking: StackingType
  83. Tells Kahakai what stacking type to use for menus. Can be one of: AlwaysOnTop, AlwaysAtBottom or Normal. Default type is Normal.
  85. screen0.transientAbove: Bool
  86. Tells Kahakai to use special handling of transient windows. When turned on Kahakai will always keep transient windows above and focused relative to the the 'transient for' window. Default value is True.
  88. screen0.focusRevertTo: RevertType
  89. Specifies where the input focus reverts to if a window or menu becomes not viewable. RevertType can be one of Root or Window. When set to Root, Kahakai will revert focus to the root window. When set to Window, Kahakai will revert focus to the last focused window that is viewable. Default value is Window.
  91. Dockappholder Resources
  93. It is possible to have more than one dockappholder running. First dockappholder should be named dock0 and the second dock1 and so on. One dockappholder is always running whether you have a dock0 line in your CONFIGFILE or not.
  95. screen0.dock[num].geometry: OffsetString
  96. Define dockappholder position. OffsetString must be an X offset string of form: [{+-}<xoffset>{+-}<yoffset>]
  98. screen0.dock[num].order: Regular Expression List
  99. A whitespace separated list of regular expressions describing how to order the dockapps in the dockappholder. Dockapps can be ordered by window name, window class and window title. For window name use n/Regexp/ , `Regexp' being the POSIX regular expression used for window name matching. For window class use c/Regexp/ , `Regexp' being the POSIX regular expression used for window class matching. For window title use t/Regexp/ , `Regexp' being the POSIX regular expression used for window title matching.
  101. Example:
  103. screen0.dock0.order: n/.*meter$/ c/pager/
  105. This will put dockapp window with name ending with `meter' at the first position in dockappholder and dockapp with classname containing `pager' at second position. All dockapp windows that doesn't match any regular expression will be put in last dockapp at last position.
  107. screen0.dock[num].desktopMask: Desktop number list
  108. A whitespace separated list of desktop numbers. Dockappholder will only appear in desktops specified by this list. To make dockappholder appear in all desktops, replace list with the string `All'. Default is All
  110. screen0.dock[num].direction: Direction
  111. Dockappholder direction {Vertical, Horizontal}
  113. screen0.dock[num].centered: Boolean
  114. True if you want the dockappholder to be centered. If direction is Vertical, yoffset from geometry resource will be ignored and dockappholder will be centered vertically. If direction is Horizontal, xoffset from geometry resource will be ignored and dockappholder will be centered horizontally.
  116. screen0.dock[num].gridSpace: Integer
  117. Number of pixels spacing between dockapps in dockappholder.
  119. screen0.dock[num].stacking: StackingType
  120. Stacking order for dockappholder {AlwaysOnTop, AlwaysAtBottom}.
  122. screen0.dock[num].inworkspace: Boolean
  123. True if you don't wont dockappholder to alter the workarea. Maximizied windows will be maximized over the dockappholder when this is set to true. Default is False.
  126. STYLES
  127. Kahakai enables you to use Blackbox specialized style files that contain X(7) resources to specify colors, textures and fonts, and thus the overall look of your window decorations and menus. However there are a few keys in Blackbox styles that Kahakai doesn't use and there are a few new keys that don't exist in standard Blackbox styles.
  129. Kahakai allows you to configure the style of menus and the windows. Dockappholders use the same style as the windows.
  131. Here are the different types of values:
  133. Color
  134. A valid X resource-style color name, e.g. `green', or `wheat'.
  135. Font
  136. XLFD (X core font) or Xft font name. Xft font names must be followed by [xft] suffix.
  137. e.g.:
  140. -adobe-courier-medium-r-normal--10-100-75-75-m-60-iso8859-1
  142. The format for Xft font names is:
  145. <family>-<size>:<name>=<value> [xft]
  147. An arbitrary set of additional elements can be appended to the Xft font name, the complete list of possible properties is:
  149. Name Type
  150. ---------------------------------
  151. family String
  152. style String
  153. slant Int
  154. weight Int
  155. size Double
  156. aspect Double (only in Xft2)
  157. pixelsize Double
  158. encoding String (only in Xft1)
  159. spacing Int
  160. foundry String
  161. core Bool (only in Xft1)
  162. antialias Bool
  163. xlfd String (only in Xft1)
  164. file String
  165. index Int
  166. rasterizer String
  167. outline Bool
  168. scalable Bool
  169. rgba Int
  171. (Defaults from resources)
  173. scale Double
  174. render Bool (only in Xft1)
  175. minspace Bool
  177. (Specific to FreeType rasterizer)
  179. charwidth Int
  180. charheight Int
  181. matrix XftMatrix
  182. charset CharSet (only in Xft2)
  183. lang String (only in Xft2)
  185. As family and size are both nearly always needed to access a Xft font, they're given a privileged place, but really they're no different than the remaining values. For elements that use an enumerated list of possible values, the values are given names which can be used in place of an integer, or can actually replace the whole name=value part. They're all unique, so this actually works. Here's a list of all of the enumerated values and the associated name:
  187. Value Element
  188. ---------------------------------
  189. light weight
  190. medium weight
  191. demibold weight
  192. bold weight
  193. black weight
  195. roman slant
  196. italic slant
  197. oblique slant
  199. proportional spacing
  200. mono spacing
  201. charcell spacing
  203. rgb rgba
  204. bgr rgba
  205. vrgb rgba
  206. vbgr rgba
  208. Some example Xft font names:
  211. times-12 [xft]
  213. 12 point times
  216. times,charter-12:bold [xft]
  218. 12 point, preferring 'times', but accepting 'charter', bold.
  221. times-12:bold:slant=italic,oblique [xft]
  223. 12 point times bold, either italic or oblique
  226. times-12:rgba=vbgr [xft]
  228. 12 point times, optimized for display on an LCD screen with sub-pixel elements arranged vertically with blue on the top and red on the bottom.
  231. times:pixelsize=100 [xft]
  233. 100 pixel times -- pixel size overrides any point size
  235. Xft opacity level
  236. Xft font opacity level. Integer value from 0 to 100, where 0 is the default non translucent opacity level and and 100 makes it a fully transparent font.
  238. Font justification
  239. Is one of left, right or center. e.g.: 'left'.
  241. Texture descriptions
  242. Texture descriptions are specified directly to the key that they should apply to, e.g.:
  245. window.label: Raised Gradient Diagonal Bevel1
  247. A texture description consists of up to five fields, which are as follows:
  250. Flat / Raised / Sunken
  252. gives the component either a flat, raised or sunken appearance.
  255. Gradient / Solid / Pixmap
  257. tells Kahakai to draw either a solid color or a gradiented texture.
  260. Horizontal / Vertical / Diagonal / Crossdiagonal / Pipecross / Elliptic / Rectangle / Pyramid
  262. Select one of these texture types. They only work when also Gradient is specified!
  265. Tiled / Scaled / Stretched
  267. Select one of these resizing methods. They only work when also Pixmap is specified!. Tiled resizing does not resize the image just tiles it, fastest method. Scaled resizing performs a normal scaling of image, all parts of the image are scaled equally. Stretched resizing only scales the middle part of the image, all borders are preserved.
  270. Interlaced
  272. tells Kahakai to interlace the texture (darken every other line). This option is most commonly used with gradiented textures, but it also works in solid textures.
  275. Bevel1 / Bevel2
  277. tells Kahakai which type of bevel to use. Bevel1 is the default bevel. The shading is placed on the edge of the image. Bevel2 is an alternative. The shading is placed one pixel in from the edge of the image.
  279. Instead of a texture description, also the option ParentRelative is available, which makes the component appear as a part of its parent, totally transparant.
  282. All gradiented textures are composed of two color values: the color and colorTo resources. When Interlaced is used in Solid mode, the colorTo resource is used to find the interlacing color.
  284. A image file must be specified for all pixmap textures. pixmap resources is used for finding the image file. Must be either a complete file path, a file path relative to Kahakai start directory or an image file in the same directory as the style file.
  286. Texture opacity level
  287. Texture opacity level. Integer value from 0 to 100, where 0 is the default non translucent opacity level and and 100 makes it a fully transparent texture. This requires that the program setting the background image has support for setting _XROOTPMAP_ID property on root window. Esetroot does this. Opacity works for all types of textures even pixmaps.
  289. Pixmap stretching borders
  290. Borders used for pixmap stretching. Format is:
  292. { LEFT, RIGHT, TOP, BOTTOM }
  294. LEFT being the width of left border, RIGHT being the width of right border, TOP being the height of top border and BOTTOM being the height of bottom border. Only graphics not within any of the borders will be scaled when stretching pixmap.
  296. Here are the keys Kahakai understands together with the value they should contain.
  298. Window Keys
  299. Controls the look of the window decorations. The '*' in the window keys can be one of: title, label, handle, button or grip.
  301. window.*.focus: Texture description
  302. window.*.focus.opacity: Texture opacity level
  303. window.*.focus.color: Color
  304. window.*.focus.colorTo: Color
  305. window.*.focus.pixmap: Pixmap
  306. window.*.focus.border: Border
  308. Texture type, opacity level, colors and pixmap used for focused window textures.
  310. window.*.unfocus: Texture description
  311. window.*.unfocus.opacity: Texture opacity level
  312. window.*.unfocus.color: Color
  313. window.*.unfocus.colorTo: Color
  314. window.*.unfocus.pixmap: Pixmap
  315. window.*.unfocus.border: Border
  317. Texture type, opacity level and colors used for unfocused window textures.
  319. window.label.focus.textColor: Color
  320. window.label.focus.textColor.opacity: Xft opacity level
  321. window.label.focus.textShadowColor: Color
  322. window.label.focus.textShadowColor.opacity: Xft opacity level
  324. Color and opacity level used for focused window label font.
  326. window.label.focus.textShadowXOffset: Integer
  327. window.label.focus.textShadowYOffset: Integer
  329. X and Y shadow offset for focused window label. If neither XOffset or YOffset are specified or both are zero no shadow will be rendered.
  331. window.label.unfocus.textColor: Color
  332. window.label.unfocus.textColor.opacity: Xft opacity level
  333. window.label.unfocus.textShadowColor: Color
  334. window.label.unfocus.textShadowColor.opacity: Xft opacity level
  336. Color and opacity level used for unfocused window label font.
  338. window.label.unfocus.textShadowXOffset: Integer
  339. window.label.unfocus.textShadowYOffset: Integer
  341. X and Y shadow offset for unfocused window label. If neither XOffset or YOffset are specified or both are zero no shadow will be rendered.
  343. window.button.focus.picColor: Color
  344. Color used for focused window button symbols.
  346. window.button.unfocus.picColor: Color
  347. Color used for unfocused window button symbols.
  349. window.button.pressed.picColor: Color
  350. Color used for pressed button symbols.
  352. window.justify: Font justification
  353. Font justification for window labels.
  355. window.font: Font
  356. Font for window titles.
  358. borderWidth: Integer
  359. Integer value for window border width.
  361. borderColor: Color
  362. Color of window border.
  364. outlineColor: Color
  365. Color of window outline used for non-opaque moving and resizing.
  367. window.title.height: Integer
  368. Integer value for forced titlebar height. If key isn't defined the title height is set by the height of the font.
  370. Menu Keys
  371. Controls the look of the menus. The '*' in the menu keys can be one of: title, frame or hilite.
  373. menu.*: Texture description
  374. menu.*.opacity: Texture opacity level
  375. menu.*.color: Color
  376. menu.*.colorTo: Color
  377. menu.*.pixmap: Pixmap
  378. menu.*.border: Border
  380. Texture type, opacity level and colors used for menu textures.
  382. menu.*.textColor: Color
  383. menu.*.textColor.opacity: Xft opacity level
  384. menu.*.textShadowColor: Color
  385. menu.*.textShadowColor.opacity: Xft opacity level
  387. Color and opacity level used for menu fonts.
  389. menu.*.textShadowXOffset: Integer
  390. menu.*.textShadowYOffset: Integer
  392. X and Y shadow offset for menu item. If neither XOffset or YOffset are specified or both are zero no shadow will be rendered.
  394. menu.*.justify: Font justification
  395. Font justification for menu items.
  397. menu.*.font: Font
  398. Font for menu items.
  400. menu.bullet.look: String or 'char'
  401. String or character code used for menu bullets.
  403. menu.checkbox.true.look: String or 'char'
  404. String or character code used for true checkboxes.
  406. menu.checkbox.false.look: String or 'char'
  407. String or character code used for false checkboxes.
  409. menu.borderWidth: Integer
  410. Integer value for menu border width.
  412. menu.item.height: Integer
  413. Integer value for forced menu frame item height. If key isn't defined the frame menu item height is set by the height of the font.
  415. menu.title.height: Integer
  416. Integer value for forced menu title item height. If key isn't defined the frame menu title height is set by the height of the font.
  418. Dockappholder Keys
  419. Controls the look of the dockappholders. A different texture can be assigned to each dockappholder. '[ID]' should be replaced by a dockappholder ID number. A dockappholder ID is >=0 and depends on the dockappholder configuration in the rc-file.
  421. dockappholder.dock[ID].frame: Texture description
  422. dockappholder.dock[ID].frame.opacity: Opacity level
  423. dockappholder.dock[ID].frame.color: Color
  424. dockappholder.dock[ID].frame.colorTo: Color
  425. dockappholder.dock[ID].frame.pixmap: Pixmap
  426. dockappholder.dock[ID].frame.border: Border
  428. Texture type, opacity level and colors used for dockappholder 'dock[ID]'s frame texture.
  430. dockappholder.dock[ID].borderWidth: Integer
  431. Border width used for dockappholder 'dock[ID]'s border.
  433. dockappholder.dock[ID].borderColor: Color
  434. Border color used for dockappholder 'dock[ID]'s border.
  436. Button Keys
  437. Controls the look of the titlebar buttons. For backwards compatibility with blackbox styles Kahakai still understands the above mentioned window.button.* key, but Kahakai have a much more advanced configuration system for titlebar buttons. The Kahakai titlebar configuration system allows you to have any number of titlebar buttons and the position and look for each button can be specified.
  439. A titlebar button works just like a checkbox. It has two states, a 'false' state and a 'true' state. Which state the button is in depends on a variable and the look of each of these states can be specified. The '[ID]' must be a number >= 0. For Kahakai to read button configuration with an ID of 2, there must be a configuration with an ID of 0 and an ID of 1, this is because Kahakai stops reading button configurations when it comes to missing ID.
  441. window.button[ID].foreground: Boolean
  442. True if you want Kahakai to draw its standard foreground graphics on the button. Graphics drawn depends on the buttons state configuration.
  444. window.button[ID].state: Checkbox State
  445. This specifies what variable the button should monitor for its state. Can be one of these:
  446. MAXIMIZED
  447. MINIMIZED
  448. SHADED
  449. STICKY
  450. ALWAYSONTOP
  451. ALWAYSATBOTTOM
  452. DECORTITLE
  453. DECORHANDLE
  454. DECORBORDER
  455. DECORALL
  456. FULLSCREEN
  457. CLOSE
  458. None
  460. When set to None, titlebar button will only have one state (false state). Default is None.
  462. window.button[ID].autoplace: Autoplace Type
  463. This specifies the autoplace type for the button. Can be one of Left, Right or False. Left will automatically place the button on the left side of the titlebar so that it doesn't cover any other button and Right will automatically place the button on the right side. No automatic placement will be used when set to False. Default is False.
  465. window.button[ID].position: Offset
  466. X coordinate for button. If offset is positive, then the left side of the titlebar will be used as X coordinate zero. If offset is negative, then the right side of the titlebar will be used as X coordinate zero. 'position' resource will be ignored if not 'autoplace' resource is set to False.
  468. window.button[ID].[STATE].focus: Texture description
  469. window.button[ID].[STATE].focus.opacity: Opacity level
  470. window.button[ID].[STATE].focus.color: Color
  471. window.button[ID].[STATE].focus.colorTo: Color
  472. window.button[ID].[STATE].focus.pixmap: Pixmap
  473. window.button[ID].[STATE].focus.border: Border
  474. window.button[ID].[STATE].unfocus: Texture description
  475. window.button[ID].[STATE].unfocus.opacity: Opacity level
  476. window.button[ID].[STATE].unfocus.color: Color
  477. window.button[ID].[STATE].unfocus.colorTo: Color
  478. window.button[ID].[STATE].focus.border: Border
  479. window.button[ID].[STATE].unfocus.pixmap: Pixmap
  480. window.button[ID].[STATE].pressed: Texture description
  481. window.button[ID].[STATE].pressed.opacity: Opacity level
  482. window.button[ID].[STATE].pressed.color: Color
  483. window.button[ID].[STATE].pressed.colorTo: Color
  484. window.button[ID].[STATE].pressed.pixmap: Pixmap
  485. window.button[ID].[STATE].pressed.border: Border
  487. Texture type, opacity level and colors used for titlebar button[ID]. [STATE] can be 'false' or 'true'. If button have more than one state then both 'false' and 'true' state textures should be specified. If button have only one state then only 'false' state needs to be specified.
  489. rootCommand: Command line
  490. This command is executed whenever this style is loaded. Typically it sets the root window to a nice picture.
  492. Default style file is /usr/share/kahakai/styles/Default. You can study or edit this style to grasp how the style mechanism works.
  495. MENUS
  497. All menus must be defined in the menu file.
  499. A menu definition starts with a [start] tag and ends with an [end] tag. Between the [start] and the [end] tag a number of [item], [title], [sub] and [checkbox] tags should be placed. The looks and action lists are the only things separating the first three menu item types. All three of these tags could be followed by a (string), "string", {string} and <string>. A [checkbox] tag is basically an [item] tag with two states.
  501. Kahakai menu system is compatible with blackbox(1) menu system, so higher level tags as [begin], [exec], [submenu], [nop], [restart] and [exit] are supported. blackbox(1) also supports [styledir], [reconfig] and [config] tags, these tags are not used by Kahakai.
  503. () = menu item title
  504. "" = action
  505. {} = command line
  506. <> = sub menu
  508. e.g.:
  511. [start] (menu)
  512. [title] (Menu)
  513. [item] (Xterm) {xterm}
  514. [sub] (Programs) <progs>
  515. [item] (Restart) "restart"
  516. [item] (Exit) "exit"
  517. [end]
  519. It is possible to start defining a new menu within another menu. e.g.:
  522. [start] (menu)
  523. [start] (menu2)
  524. [item] (not smart) {rm -rf ~}
  525. [end]
  526. [sub] <menu2>
  527. [end]
  529. [include] tags can be used anywhere in a menu file to include the contains of another file. e.g.:
  532. [include] (/home/user/.waimea/rootmenu)
  534. Environment Variables And Window Info Expansion
  535. Menu item titles include filenames and submenu references can contain environment variables. e.g.:
  537. [item] (Logout $USER) "exit"
  539. $USER will be replaced with USER environment variable.
  541. Menu mapped by event occurring on a window.* window can contain special window info character sequences. These character sequences are expanded with the current window info when menu is mapped. e.g.:
  544. [item] (win name: \n)
  546. Will be expanded to:
  549. [item] (win name: windowname)
  551. Where windowname is the actual class name of the window.
  552. These are the character sequences that Kahakai recognizes:
  555. "\c" Window class
  556. "\n" Window class name
  557. "\h" Host name for window owner
  558. "\p" PID of window owner
  560. If some window info isn't known for a window, the character sequence used for expanding this info will be replaced with an empty string.
  562. All special characters need to be escaped (with a `\') to protect them from expansion. Special characters are:
  564. ( ) { } < > [ ] " $
  566. Checkboxes
  567. A checkbox item is a item that have two states and a flag decides which state the item is in. e.g.:
  570. [checkbox=STICKY] @FALSE (Sticky) "sticky" @TRUE (Sticky) "unsticky"
  572. Flag to decide which mode to be in for this checkbox is STICKY (the sticky flag for a window). If STICKY flag is 'False' the checkbox item will be in mode defined by menu string after @FALSE and if STICKY flag is 'True' the checkbox item will be in mode defined by the menu string after @TRUE.
  574. Here is the list of flags that can be used with checkbox items:
  575. MAXIMIZED
  576. MINIMIZED
  577. SHADED
  578. STICKY
  579. ALWAYSONTOP
  580. ALWAYSATBOTTOM
  581. DECORTITLE
  582. DECORHANDLE
  583. DECORBORDER
  584. FULLSCREEN
  586. Taskswitcher
  587. Predefined menu named "__windowlist__" can be used in menu file and scripts to access the taskswitcher menu.
  589. Window merging
  590. Predefined menus named "__mergelist__", "__mergelist_vertically__" and "__mergelist_horizontally__" can be used in menu file and scripts to access window merging menus.
  592. Dynamic menus
  593. Kahakai supports dynamic menus. A Dynamic menu is a menu that is generated when mapped. Compared to a normal static menu that must be fully defined in the MENUFILE the definition of a dynamic menu only consists of a command line. The command line is executed when the menu is to be mapped and the standard output from the command is parsed in the same way as the MENUFILE to generate the dynamic menu. Every time the menu is remapped the command line is executed and a new menu is generated. A dynamic menu is defined as a submenu link in the MENUFILE or as a menu_name parameter to one of the menumap actions. A dynamic menu definition must start with a '!' character and be followed by a command line. e.g.:
  596. [sub] (Styles) <!styledir.pl>
  598. Creates a submenu item with title 'Styles' and the submenu for the item is dynamic menu created by execution of styledir.pl script. Dynamic menus can contain definitions of other dynamic menus.
  600. Default menu file is /usr/share/kahakai/menu. You can study or edit this menu file to grasp how the menu system works.
  603. ENVIRONMENT
  605. HOME
  606. Kahakai uses this variable to find its .kahakai directory.
  607. DISPLAY
  608. When no other display was given on the command line, Kahakai will start on the display specified by this variable.
  611. FILES
  613. ~/.kahakai/config
  614. User configuration file. See CONFIG FILE section for further details.
  616. /usr/share/kahakai/config
  617. The system wide configuration file. See CONFIG FILE section for further details.
  619. /usr/share/kahakai/style/Default.style
  620. The system wide style file. See STYLES section for further details.
  622. /usr/share/kahakai/menu
  623. The system wide menu file. See MENUS section for further details.
comments powered by Disqus