~~Title: Go ~~
$$ Argument
$$ Type
$$ Possible values
$$ Description
$$ BACK
$$ /S
$$ //(no value)//
$$ Navigate to the previous folder in the [[:basic_concepts:the_lister:navigation:recent_and_history_lists|history list]]. The history list preserves the file selection and scroll offset state of the folder. The **BACK** argument can be combined with the **UP** argument; in that case, if the previous folder in the history list is the current folder's parent, Opus will go back (preserving selections, etc) rather than **UP**.
You can combine this with arguments that change the target of the navigation, like **NEW**, **NEWTAB**, **OPENINDUAL** etc.
``Go BACK``
$$ BACKLIST
$$ /O
$$ //(no value)//
$$ Display a list of all previous folders in the history list (acts as a [[:customize:creating_your_own_buttons:editing_the_toolbar:dynamic_buttons|dynamic button]]). This is used on the drop-down menu attached to the Back button on the default toolbar.
``Go BACKLIST``
$$
$$
$$ **namesonly**
$$ Display only folder names, not full paths. Tooltips will show full paths when hovering over items.
``Go BACKLIST=namesonly``
$$
$$
$$ **noicons**
$$ Does not display icons on the generated history list.
``Go BACKLIST=noicons``
$$
$$
$$ **keys**
$$ Assigns the accelerator keys **0** through **9** to the first ten items displayed on the generated history list.
``Go BACKLIST=noicons,keys``
$$
$$
$$ **sort**
$$ Sorts the history list alphabetically instead of in chronological order.
``Go BACKLIST=sort``
$$ COMPATIBILITYFILES
$$ /S
$$ //(no value)//
$$ Switch between a folder and its compatibility store. Not all folders have compatibility stores - this command will do nothing in that case. For example, from **C:\Program Files** you would be taken to **C:\Users\...\VirtualStore\Program Files**, and vice versa.
The compatibility store concept was introduced in Windows Vista with the addition of UAC, to support older software that tried to save files in the program folder. These days the concept is hardly ever encountered.
``Go COMPATIBILITYFILES``
$$ CONNECT
$$ /O
$$ //(no value)//
$$ Display the system dialog that allows you to map a network share to a drive letter.
``Go CONNECT``
$$
$$
$$ ////
$$ Map the specified network path to a drive letter.
``Go CONNECT \\server\share``
$$ COPYARGS
$$ /K/R
$$ //(no value)//
$$ A command like `Go FOLDERCONTENT=copy` which generates a list of buttons, each of which copies or moves files to or from a different place. Each generated button runs the Opus **Copy** command, which takes different arguments to the **Go** command.
The **COPYARGS** argument allows you to specify one or more additional **Copy**-command arguments which are added to each of the generated buttons.
Since this is a "raw" argument, it should be the last thing on the line. All text after the word "COPYARGS" will be taken as-is, including any quote characters, and appended to the copy command of each generated button.
``Go C:\ FOLDERCONTENT=copy COPYARGS COPYFILETIMES=no``
$$ CURDIR
$$ /O
$$ //(no value)//
$$ Activates "current directory" mode for the **Go** command. When used with a drive letter for the **PATH** argument, this mode makes Opus navigate to the most recently accessed folder on the specified drive. Opus will remember the "current directory" for each drive in your system, even from one session to the next.
When used in conjunction with the **DRIVEBUTTONS** argument, the generated drive letter buttons will have the same behaviour, and will highlight to indicate the "current drive". In this way you can click around from one drive to another remembering the previously used folder on each drive.
``Go D: CURDIR``\\
``Go DRIVEBUTTONS=fixed CURDIR``
$$
$$
$$ **rootmode**
$$ Modifies "current directory" mode so that clicking the button for the drive you are already on takes you to the root of the drive (ordinarily it would do nothing).
``Go DRIVEBUTTONS CURDIR=rootmode``
$$ CURRENT
$$ /S
$$ //(no value)//
$$ Indicates the current source folder. This argument is used to open the current folder in another tab, Lister or file display.
``Go CURRENT OPENINDUAL``
$$ DESTPATH
$$ /S
$$ //(no value)//
$$ Indicates the current destination folder. This argument is used to open the destination folder in the source file display (or another Lister, or tab).
``Go DESTPATH``
$$ DISCONNECT
$$ /S
$$ //(no value)//
$$ Display the system dialog that allows you to disconnect (unmap) a network share.
``Go DISCONNECT``
$$ DRIVEBUTTONS
$$ /O
$$ //(no value)//
$$ Display a list of all the drives currently on your system (acts as a [[:customize:creating_your_own_buttons:editing_the_toolbar:dynamic_buttons|dynamic button]]). Clicking a button navigates the source folder to that drive's root. The drive buttons can also be right-clicked to display the context menu for each drive.
The various values for this argument can be used to restrict the drives that are shown.
``Go DRIVEBUTTONS``
$$
$$
$$ **fixed**
$$ Only display the fixed drives (hard drives).
``Go DRIVEBUTTONS=fixed``
$$
$$
$$ **network**
$$ Only display network (mapped) drives.
``Go DRIVEBUTTONS=network``
$$
$$
$$ **cdrom**
$$ Only display CD-ROM (and DVD) drives.
``Go DRIVEBUTTONS=cdrom``
$$
$$
$$ **removable**
$$ Only display removable drives (floppies, and some USB drives).
``Go DRIVEBUTTONS=removable,cdrom``
$$
$$
$$ **ramdisk**
$$ Only display RAM drives.
``Go DRIVEBUTTONS=ramdisk``
$$
$$
$$ **mtp**
$$ Only display MTP (portable) devices.
``Go DRIVEBUTTONS=mtp``
$$
$$
$$ **iconlettersoff**
$$ Disable the display of small drive letters as part of each drive's icon.
``Go DRIVEBUTTONS=fixed,iconlettersoff``
$$
$$
$$ **iconletterson**
$$ Enable the display of small drive letters as part of each drive's icon.
``Go DRIVEBUTTONS=iconletterson``
$$
$$
$$ **labels**
$$ Displays the label of each drive. By default only each drive's letter is shown.
``Go DRIVEBUTTONS=fixed,labels``
$$
$$
$$ **noletters**
$$ Prevents the display of each drive's letter, if labels are being shown using the **labels** keyword. Note that if you want to completely disable any text being displayed in the button you need to turn off the button's **Show Label** checkbox in the [[:customize:creating_your_own_buttons:command_editor|button editor]].
``Go DRIVEBUTTONS=labels,noletters``
$$
$$
$$ **multifunc**
$$ The generated drive buttons will be [[:customize:creating_your_own_buttons:editing_the_toolbar:multiple_function_buttons|multiple function buttons]] (three-button buttons) - clicking them with the left mouse button will act as if **OPENINLEFT** were set, the right button will act as if **OPENINRIGHT** were set, and the middle mouse button will act as if **NEW** were set.
``Go DRIVEBUTTONS=fixed,network,multifunc``
$$
$$
$$ **multifunctabs**
$$ Similar to **multifunc**, except the left and right mouse button functions will open a new tab on the appropriate side of the Lister. You can control how new tabs are opened with the **NEWTAB** argument.
``Go DRIVEBUTTONS=multifunctabs,labels,fixed``
$$
$$
$$ **lettersbeforelabels**
$$ When showing both drive letters and labels, the letters will be displayed first. Without this letters are shown following the labels.
``Go DRIVEBUTTONS=fixed,labels,lettersbeforelabels``
$$
$$
$$ **offline**
$$ When showing network drives, only offline drives will be shown (by default both connected and offline drives are shown).
``Go DRIVEBUTTONS=network,offline``
$$
$$
$$ **online**
$$ When showing network drives, only online (connected) drives will be shown.
``Go DRIVEBUTTONS=network,online``
$$
$$
$$ **hideempty**
$$ Hides the display of empty drives. Removable disks (floppies, card readers, DVDs) that have no media inserted in them will not be displayed.
``Go DRIVEBUTTONS=cdrom,removable,hideempty``
$$
$$
$$ **+**////
$$ Only display the specified drive letters. Any drives not specified will be hidden.
``Go DRIVEBUTTONS=removable,+fhjm``
$$
$$
$$ **-**////
$$ Do not display the specified drive letters.
``Go DRIVEBUTTONS=-d``
$$ DUALPATH
$$ /K
$$ ////
$$ Specify a path to read into the destination file display of a dual-display Lister (the standard **PATH** argument reads into the source file display).
``Go C:\ DUALPATH D:\``
$$ EJECT
$$ /S
$$ //(no value)//
$$ Trigger an eject of the media in the drive specified by the **PATH** argument. This command has no effect if the drive does not have an eject mechanism.
``Go D: EJECT``
$$ EXISTINGLISTER
$$ /O
$$ //(no value)//
$$ If the specified folder is already open in an existing lister (including inactive folder tabs in other windows) then the command will activate that lister and the appropriate tab within it and do nothing else. If another window is found then the rest of the command's arguments are ignored. If the specified path is not already open in another window then the command continues as if the **EXISTINGLISTER** argument had not been given.
``Go "C:\Program Files" NEW EXISTINGLISTER``
$$
$$
$$ **seltabsonly**
$$ Only selected folder tabs will be considered. If the specified folder is open in an existing lister, but in a folder tab which is not currently selected, then that tab will be ignored.
``Go "C:\Program Files" NEW EXISTINGLISTER=seltabsonly``
$$ EXPANDBRANCH
$$ /O
$$ //(no value)//
$$ When [[:preferences:preferences_categories:file_displays:folder_expansion|Folder Expansion]] is turned on in Preferences, this command lets you programmatically expand folders in the current file display.
When used with no value, all currently selected folders will be expanded. You can combine this with the **PATH** argument to specify the item to expand by path - or in conjunction with the **wild** or **regexp** keywords, by pattern matching.
``Go EXPANDBRANCH``
$$ $$ $$ **case**
$$ Use with `regexp` or `wild` to make the wildcard operation case sensitive.
``Go EXPANDBRANCH=toggle,regexp,case PATH [a-z]+``
$$ $$ $$ **clearselect**
$$ Use with `collapse` to automatically clear the selection of any files or folders inside the folders being collapsed.
``Go EXPANDBRANCH=collapse,clearselect``
$$ $$ $$ **collapse**
$$ Collapses currently selected folders if they're currently expanded. Additionally, if a single file or unexpanded folder is selected and it's inside an expanded parent folder, the parent folder will be collapsed.
``Go EXPANDBRANCH=collapse``
$$ $$ $$ **noparent**
$$ When used with `Go EXPANDBRANCH=collapse` this prevents it collapsing the parent folder of a selected file or unexpanded folder.
``Go EXPANDBRANCH=collapse,noparent``
$$ $$ $$ **regexp**
$$ The **PATH** argument will be interpreted as a [[..:..:wildcard_reference:regular_expression_syntax|regular expression]].
``Go EXPANDBRANCH=toggle,regexp PATH [a-z]+``
$$ $$ $$ **script**
$$ When run from a script, uses the folders added to the [[:reference:scripting_reference:scripting_objects:command|Command]] object to expand/collapse rather than selected folders.
``Go EXPANDBRANCH=script,toggle``
$$ $$ $$ **toggle**
$$ Toggles the expansion state of currently selected folers.
``Go EXPANDBRANCH=toggle``
$$ $$ $$ **toggleall**
$$ Toggles the expansion state of selected folders as a group. If any are not expanded, all will be expanded. If all are expanded, all will be collapsed.
``Go EXPANDBRANCH=toggleall``
$$ $$ $$ **top**
$$ Restricts the command to expanding/collapsing items at the top level, ignoring nested items. (Has no effect if the **PATH** argument is used to specify the item).
``Go EXPANDBRANCH=toggleall,top``
$$ $$ $$ **wild**
$$ The **PATH** argument will be interpreted as a [[..:..:wildcard_reference:pattern_matching_syntax|wildcard]]. Note the wildcard is tested against names only, not complete paths. Any folders matching the wildcard will be expanded or collapsed, whether they are currently selected or not.
``Go EXPANDBRANCH=toggleall,top,wild PATH *_backup``
$$ FDBBUTTONS
$$ /O
$$ //(no value)//
$$ This command acts as a [[:customize:creating_your_own_buttons:editing_the_toolbar:dynamic_buttons|dynamic button]]. It lets you add buttons to a toolbar that mimic the standard File Display Border buttons. The command is designed to be used on the File Display toolbar as an alternative to the standard buttons.
By default the command will add //Back//, //Forward//, //Up//, //Copy//, //Swap// and //Toggle Layout// buttons. You can use the various keywords to control exactly which buttons are added.
``Go FDBBUTTONS``
$$
$$
$$ ////
$$ Use combinations of the keywords **back**, **forward**, **up**, **copy**, **swap** and **layout** to control exactly which buttons are added.
``Go FDBBUTTONS back,forward`` - show //Back// and //Forward// buttons\\
``Go FDBBUTTONS -layout`` - show all but the //Toggle Layout// button
$$
$$
$$ **noicons**
$$ Do not display icons for the generated buttons.
``Go FDBBUTTONS -layout,noicons``
$$
$$
$$ **nolabels**
$$ Do not display labels for the generated buttons.
``Go FDBBUTTONS swap,layout,nolabels``
$$
$$
$$ **dropdowns**
$$ Make the generated buttons drop-down buttons where applicable.
``Go FDBBUTTONS back,forward,up,dropdowns``
$$ FINDTITLE
$$ /K
$$ ////
$$ Finds all currently open Listers with titles that match the specified string, and brings them to the front. The string to search for can be a specific title or a [[..:..:wildcard_reference:pattern_matching_syntax|wildcard pattern]].
``Go FINDTITLE *Projects``*
$$ FOLDERCONTENT
$$ /O
$$ //(no value)//
$$ Display the contents of the path specified by the **PATH** argument in drop-down menus (acts as a [[:customize:creating_your_own_buttons:editing_the_toolbar:dynamic_buttons|dynamic button]]). Sub-folders in the generated list can be selected to navigate to that location, and files in the generated list can be selected to open that file. You can also right-click on items to display their context menus, and drag-and-drop files to folders (to copy or move them) or over other files (to open them). If you hover the mouse over a sub-folder it will expand to display another menu showing the contents of the sub-folder.
When used with **FOLDERCONTENT** only, the **PATH** argument supports multiple paths separated with a vertical bar (**%%|%%**). For example, this would let you reproduce (to some extent anyway) the Windows start menu in a drop-down menu in a Lister, by showing both the current user's start folder and the common (all users) start folder.
``Go /start|/commonstartmenu FOLDERCONTENT``
$$
$$
$$ **button**
$$ Sub-folders in the generated **FOLDERCONTENT** list will appear as menu-buttons. Clicking the button part will read the sub-folder, expanding the drop-down will display its contents.
``Go C: FOLDERCONTENT=button``
$$
$$
$$ **nomenusel**
$$ Hovering over a sub-folder will expand it, while single-clicking will navigate to it. Also forces empty folders to be hidden, even if **showempty** is also specified.
``Go C: FOLDERCONTENT=nomenusel``
$$
$$
$$ **dblclickmenu**
$$ For folders with sub-items, both hovering and single-clicking will expand their sub-menus, while double-clicking will navigate to them. For folders without sub-items, a single-click will be enough to navigate to them.
``Go C: FOLDERCONTENT=dblclickmenu``
$$
$$
$$ **norecurse**
$$ Prevents sub-folders in the generated list from being expanded; the list will be limited to a single folder level (although sub-folders will still be displayed, you will not be able to expand them).
``Go C: FOLDERCONTENT=norecurse``
$$
$$
$$ **noparselinks**
$$ Prevents shortcuts from being resolved. Without this, a shortcut to a folder will be expandable just like a normal sub-folder.
``Go /profile FOLDERCONTENT=noparselinks``
$$
$$
$$ **nocontext**
$$ Prevents right-clicking items in the list to show their context menus.
``Go /profile FOLDERCONTENT=nocontext``
$$
$$
$$ **nodirs**
$$ Excludes sub-folders from the generated list - only files will be shown.
``Go /temp FOLDERCONTENT=nodirs``
$$
$$
$$ **nofiles**
$$ Excludes files from the generated list - only folders will be shown.
``Go C: FOLDERCONTENT=nofiles``
$$
$$
$$ **showhidden**
$$ Includes hidden files and folders in the list - without this, items with the **H** attribute set will be excluded.
``Go C: FOLDERCONTENT=nofiles,showhidden``
$$
$$
$$ **showempty**
$$ Empty sub-folders will be included in the generated list. Without this, empty sub-folders are excluded.
``Go CURRENT FOLDERCONTENT=showempty``
$$
$$
$$ **filefilter=**//<pattern>//
$$ Specifies a [[..:..:wildcard_reference:pattern_matching_syntax|wildcard pattern]] that the names of files must match to be included in the generated list (without this, all files are included).
Because this keyword requires an embedded equals sign, you must enclose the entire argument value in quotes to avoid confusing the command parser.
``Go C: FOLDERCONTENT="filefilter=*.exe"``
If you need a comma (,) character within the pattern, put embedded quotes around the pattern as well. The examples below both specify ***,*** as the pattern:
``Go C: FOLDERCONTENT="filefilter=""*,*"""``\\
``Go C: FOLDERCONTENT="filefilter=""*,*"",nodirs"``
$$
$$
$$ **dirfilter=**//<pattern>//
$$ Specifies a [[..:..:wildcard_reference:pattern_matching_syntax|wildcard pattern]] that folder names must match to be included in the generated list (without this, all folders are included).
Because this keyword requires an embedded equals sign, you must enclose the entire argument value in quotes to avoid confusing the command parser.
``Go C:\Work FOLDERCONTENT="dirfilter=~(.svn)"``
If you need a comma (,) character within the pattern, put embedded quotes around the pattern, similar to the **filefilter** examples above.
$$
$$
$$ **maxfiles=**//<num>//
$$ Specify the maximum number of files to list at each level. If menus for sub-folders are generated, each menu is limited in a similar way.
Because this keyword requires an embedded equals sign, you must enclose the entire argument value in quotes to avoid confusing the command parser.
``Go C: FOLDERCONTENT="maxfiles=5,sortdate"``
If you wish to exclude files entirely, it is more efficient to use **nofiles** rather than **maxfiles=0**.
$$
$$
$$ **maxdirs=**//<num>//
$$ Specify the maximum number of directories to list at each level. If menus for sub-folders are generated, each menu is limited in a similar way.
Because this keyword requires an embedded equals sign, you must enclose the entire argument value in quotes to avoid confusing the command parser.
``Go C: FOLDERCONTENT="maxdirs=10"``
If you wish to exclude directories entirely, it is more efficient to use **nodirs** rather than **maxdirs=0**.
$$
$$
$$ **maxdepth=**//<levels>//
$$ Specify the maximum number of levels deep that sub-folders can be expanded in the generated list.
Because this keyword requires an embedded equals sign, you must enclose the entire argument value in quotes to avoid confusing the command parser.
``Go C: FOLDERCONTENT="maxdepth=10"``
$$
$$
$$ **hideext**
$$ Do not show the filename extensions for files in the generated list.
``Go /mydocuments FOLDERCONTENT=hideext``
$$
$$
$$ **sortext**
$$ Sorts files in the generated list by file extension.
``Go /temp FOLDERCONTENT=nodirs,sortext``
$$
$$
$$ **sortsize**
$$ Sorts files in the generated list by size.
``Go "C:\Program Files" FOLDERCONTENT=sortsize``
$$
$$
$$ **sortdate**
$$ Sorts files in the generated list by timestamp.
``Go /downloads FOLDERCONTENT=sortdate``
$$
$$
$$ **sortnone**
$$ Do not sort the list at all. Files and folders will still be grouped but, within each group, they will be displayed in the order the operating system returned them. Often be the same as sorting by name, but can result in special or random orders in some folders.
Useful with the //Quick Access// folder (renamed //Home// in later versions of Windows 11), where the order is something you define and usually want preserved anywhere the items are displayed.
``Go /quickaccess FOLDERCONTENT=norecurse,nofiles,sortnone``
$$
$$
$$ **sortreverse**
$$ Reverse the normal sort order of items in the generated list.
``Go /downloads FOLDERCONTENT=sortdate,sortreverse``
$$
$$
$$ **copy**
$$ The generated list is dedicated to copying selected files to the folders shown in the list. This modifies the standard behaviour when you select a sub-folder from the drop-down menu. For example, if you select some files in the current folder, and then choose a sub-folder from the drop-down `Go FOLDERCONTENT` menu, the files would be copied to that folder.
Each generated button will run the **Copy** command. You can use the separate **COPYARGS** argument to specify additional **Copy**-command arguments which are included in each generated button.
``Go \\NAS\Music FOLDERCONTENT=nofiles,copy``
$$
$$
$$ **move**
$$ Selecting a sub-folder from the generated list will move selected files to that folder.
``Go D:\Archive\Documents FOLDERCONTENT=nofiles,move``
$$
$$
$$ **copytosource**
$$ Clicking a file or folder in the generated list will copy it into the current folder. (Note that this copy is in the opposite direction to the **copy** and **move** modes discussed just above.)
This could be useful if you have a folder containing template items which you frequently need to copy into different folders as you move around. To update the list of template items, you would just need to add or remove things (or softlinks to them) to the folder.
``Go "C:\My Templates" FOLDERCONTENT=copytosource``
Each generated button will run the **Copy** command. You can use the separate **COPYARGS** argument to specify additional **Copy**-command arguments which are included in each generated button.
``Go C:\ FOLDERCONTENT=copy COPYARGS COPYFILETIMES=no``
There are no separate "move" versions of the "copyto..." keywords, since it seems unlikely they'd be needed, but you can achieve the same thing via the **COPYARGS** argument:
``Go C:\ FOLDERCONTENT=copy COPYARGS MOVE``
$$
$$
$$ **copytodest**
$$ Similar to **copytosource**, except the item you click will be copied to the destination folder rather than the current (source) folder.
``Go "C:\Templates" FOLDERCONTENT=copytodest,nodirs``
$$
$$
$$ **copytoleft**
$$ Similar to **copytosource**, except the item you click will always be copied to the left folder (assuming a dual-display window).
``Go "C:\Templates" FOLDERCONTENT=copytoleft``
$$
$$
$$ **copytoright**
$$ Similar to **copytosource**, except the item you click will always be copied to the right folder (assuming a dual-display window).
``Go "C:\Templates" FOLDERCONTENT=copytoright``
$$
$$
$$ **useshell**
$$ Normally folder paths like **C:\** are enumerated using the native Windows API functions. If you specify the **useshell** keyword, they'll instead be enumerated using the shell (i.e. Explorer). This may give you localized names in some cases, as well as different ordering and different contents.
``Go C: FOLDERCONTENT=useshell``
$$
$$
$$ **embeddedcmddirs**
$$ If an embedded command is specified, applies it to directories as well as files. Otherwise, the embedded command is only applied to files and clicking directories will navigate to them normally.
//Example://
<code>
Go /home FOLDERCONTENT=embeddedcmddirs
[Copy ARCHIVE=7z TO /desktop CREATEFOLDER "{o|noext}_Backup"]
</code>
$$ FORWARD
$$ /S
$$ //(no value)//
$$ Navigate to the next folder in the [[:basic_concepts:the_lister:navigation:recent_and_history_lists|history list]].
You can combine this with arguments that change the target of the navigation, like **NEW**, **NEWTAB**, **OPENINDUAL** etc.
``Go FORWARD``
$$ FORWARDLIST
$$ /O
$$ //(no value)//
$$ Display a list of all subsequent folders in the history list (acts as a [[:customize:creating_your_own_buttons:editing_the_toolbar:dynamic_buttons|dynamic button]]). This is used on the drop-down menu attached to the Forward button on the default toolbar.
``Go FORWARDLIST``
$$
$$
$$ **namesonly**
$$ Display only folder names, not full paths. Tooltips will show full paths when hovering over items.
``Go FORWARDLIST=namesonly``
$$
$$
$$ **noicons**
$$ Does not display icons on the generated history list.
``Go FORWARDLIST=noicons``
$$
$$
$$ **keys**
$$ Assigns the accelerator keys **0** through **9** to the first ten items displayed on the generated history list.
``Go FORWARDLIST=noicons,keys``
$$
$$
$$ **sort**
$$ Sorts the history list alphabetically instead of in chronological order.
``Go FORWARDLIST=sort``
$$ FROMSEL
$$ /S
$$ //(no value)//
$$ Indicates the first selected folder in the source file display. This argument is used to open the selected folder (in the current file display, another tab, a new Lister, etc).
``Go FROMSEL NEW``
$$ FTP
$$ /S
$$ //(no value)//
$$ Displays the **[[:ftp:ftp_connect|FTP Connect]]** dialog, allowing you to make an ad-hoc connection to an FTP site.
``Go FTP``
$$ FTPCMD
$$ /K/R
$$ //<command>//
$$ Sends a raw command to the remote FTP server (when currently viewing an FTP directory). If no FTP site is currently connected the command has no effect. The effects of the command, if any, can be viewed in the [[:ftp:ftp_log|FTP log]].
``Go FTPCMD chmod * 755``
$$ FTPSITE
$$ /K
$$ //<site name>//
$$ Connect to an FTP site listed in the [[:ftp:ftp_address_book|FTP address book]]. The site must be specified by name, and if the site is in a sub-folder of the address book you must include the complete path of the entry. The **FTPSITE** argument is the equivalent of prefixing the site entry name with **@** in the **PATH** argument.
``Go FTPSITE "Work Servers\Dallas\Production"``
$$ FTPSITEICONS
$$ /S
$$ //(no value)//
$$ In conjunction with the **FTPSITELIST** argument, displays icons for all sites in the list generated by the command.
``Go FTPSITELIST FTPSITEICONS``
$$ FTPSITELIST
$$ /O
$$ //(no value)//
$$ Displays a list of the sites in the [[:ftp:ftp_address_book|FTP address book]](acts as a [[:customize:creating_your_own_buttons:editing_the_toolbar:dynamic_buttons|dynamic button]]).
``Go FTPSITELIST``
$$
$$
$$ //<site prefix>//
$$ Displays the FTP site list starting from a specified sub-folder of the address book.
``Go FTPSITELIST "Work Servers"``
$$ GROUPCOLLAPSE
$$ /K
$$ //<group name>//
$$ When the file display is [[:basic_concepts:sorting_and_grouping|grouped]], this command can be used to collapse a specified group. The group name must match exactly, but you can also use a [[..:..:wildcard_reference:pattern_matching_syntax|wildcard pattern]] to collapse all groups matching that pattern.
``Go GROUPCOLLAPSE`` *
$$ GROUPEXPAND
$$ /K
$$ //<group name>//
$$ Expand a specified file group. The group name must match exactly, but you can also use a [[..:..:wildcard_reference:pattern_matching_syntax|wildcard pattern]] to expand all groups matching that pattern.
``Go GROUPEXPAND`` *
$$ HEADING
$$ /O
$$ //(no value)//
$$ When used with commands which generate a list of items (see [[:customize:creating_your_own_buttons:editing_the_toolbar:dynamic_buttons|dynamic buttons]]), the **HEADING** argument adds a small heading at the start of the list. The heading will be hidden when the list is empty. Headings only happen for commands which potentially generate multiple items at the same level as the button itself.
When **HEADING** is used by itself, without specifying a text value, the main button's label text is used for the heading.
``Go DRIVEBUTTONS HEADING``
$$
$$
$$ //<heading text>//
$$ You can specify the heading text if you want it to be different to the button's label.
``Go DRIVEBUTTONS HEADING="List of Drive Buttons"``
$$ HISTORYLIST
$$ /O
$$ //(no value)//
$$ Display the contents of the history list (acts as a [[:customize:creating_your_own_buttons:editing_the_toolbar:dynamic_buttons|dynamic button]]). This is a combination of the previous (**BACKLIST**) and subsequent (**FORWARDLIST**) folders.
``Go HISTORYLIST``
$$
$$
$$ **namesonly**
$$ Display only folder names, not full paths. Tooltips will show full paths when hovering over items.
``Go HISTORYLIST=namesonly``
$$
$$
$$ **noicons**
$$ Does not display icons on the generated history list.
``Go HISTORYLIST=noicons``
$$
$$
$$ **keys**
$$ Assigns the accelerator keys **0** through **9** to the first ten items displayed on the generated history list.
``Go HISTORYLIST=noicons,keys``
$$
$$
$$ **sort**
$$ Sorts the history list alphabetically instead of in chronological order.
``Go HISTORYLIST=sort``
$$ INITIALDIR
$$ /S
$$ //(no value)//
$$ Returns the file display to the very first folder that it read.
``Go INITIALDIR``
$$ KEYARGS
$$ /K/M
$$ //<qualifier:arguments> ...//
$$ Provides an alternate way to modify the behaviour of the **Go** command depending on which qualifier keys are held down (instead of using the **@keydown** [[:customize:creating_your_own_buttons:command_modifiers|command modifier]]). This is a multiple value argument - for each qualifier key combination listed, you can define a separate set of arguments that will be used when command is run and that key combination is held.
For example, you could configure a **Go** button to open a folder in a new tab by default, but in a new Lister if the <kbd>Ctrl</kbd> key were held down.
The qualifier part of the value consists of one or more keywords that represent the qualifier keys - **ctrl**, **shift** and **alt**. These can be combined, for example **ctrlshift** means that both the <kbd>Ctrl</kbd> and <kbd>Shift</kbd> keys must be held down. You can also use the keyword **none** to indicate arguments that are applied when no qualifiers are held.
``Go FROMSEL KEYARGS "ctrl:NEW" "none:NEWTAB=findexisting"``
(Opus 13.9.3 and above:) When generating dynamic lists via Go DRIVEBUTTONS, Go FOLDERCONTENT or Go FTPSITELIST, you can also specify **mmb** as a qualifier to override the normal behavior where middle-clicks open folders in new tabs. The example below shows a list of drive buttons where middle-clicking one will open it in a new window instead of a new tab:
``Go DRIVEBUTTONS KEYARGS "mmb:NEW"``
(If you want to change what middle or right clicks do on simple buttons which always go to one specific folder, use a [[:customize:creating_your_own_buttons:editing_the_toolbar:multiple_function_buttons|Multiple Function Button]] instead.)
$$ LASTACTIVELISTER
$$ /S
$$ //(no value)//
$$ Brings the most recently active Lister to the front. If there is no valid Lister currently open, any other arguments provided to the command are used instead. So for example, you could have a global hotkey that brings the previous Lister to the front, or opens a new one if no Lister is open.
``Go LASTACTIVELISTER NEW``
$$ LASTCRUMB
$$ /S
$$ //(no value)//
$$ If the file display has a [[:basic_concepts:the_lister:navigation:breadcrumbs_location_field|breadcrumbs location field]] associated with it, and a ghost path is currently shown, this command will go to the last "crumb" in the ghost path.
``Go LASTCRUMB``
$$ LAYOUT
$$ /K
$$ //<layout name>//
$$ Opens the folder in a new Lister loaded from the specified [[:basic_concepts:the_lister:layouts|layout]]. If the layout contains more than one Lister, only the first Lister is used. The other arguments of the **Go** command can be used to override the settings in the layout.
``Go FROMSEL LAYOUT=Pictures VIEW=details``
$$ NAME
$$ /K
$$ //<name>//
$$ Specifies a name to save or load the folder tree expansion. Use with **REMEMBERTREEEXPANSION** and **RESTORETREEEXPANSION**.
``Go REMEMBERTREEEXPANSION NAME=CurrentJob``
$$ NEW
$$ /O
$$ //(no value)//
$$ Opens a new Lister. The [[:basic_concepts:the_lister:the_default_lister|Default Lister]] settings are used for the newly opened Lister, although the various other arguments for the **Go** command can be used to override the settings of the Default Lister.
``Go C:\ NEW``
$$
$$
$$ //<x>,<y>,<w>,<h>//
$$ Specify the position and size of the new Lister window. //<x>// and //<y>// represent the left and top edge coordinates of the window, and //<w>// and //<h>// the width and height.
``Go NEW 240,300,640,480``
$$
$$
$$ **max**
$$ Maximize the new Lister window. You can use the //<x>// and //<y>// parameters to control which monitor the window appears maximized on.
``Go NEW -1024,0,max``
$$
$$
$$ **min**
$$ Minimize the new Lister window. If a size and position is specified as well, it will represent the restored position once you un-minimize (restore) the Lister.
``Go NEW 1800,50,1024,768,min``
$$
$$
$$ **norm**
$$ The new Lister window is to be neither minimized nor maximized. Use this to override if the Default Lister is maximized, for example.
``Go NEW norm``
$$
$$
$$ **source**
$$ Set the new Lister to be the current source.
``Go FROMSEL NEW=source``
$$
$$
$$ **dest**
$$ Set the new Lister to be the destination.
``Go C:\Backup NEW=dest``
$$
$$
$$ **lockoff**
$$ The new Lister will be set as "off" - neither [[:basic_concepts:source_and_destination|source nor destination]].
``Go NEW=off``
$$
$$
$$ **tree**
$$ Opens the folder tree in the new Lister.
``Go C:\Windows NEW=tree``
$$
$$
$$ **notree**
$$ Does not open the folder tree in the new Lister.
``Go NEW=0,0,640,480,notree``
$$
$$
$$ **dual**
$$ Open the new Lister in [[:basic_concepts:the_lister:dual_display|dual-display]] mode, taking the vertical or horizontal layout from the Default Lister.
``Go NEW=dual C:\ DUALPATH D:\``
$$
$$
$$ **dualhoriz**
$$ Opens the new Lister in dual-display mode, laid out horizontally.
``Go NEW=dualhoriz FROMSEL``
$$
$$
$$ **dualvert**
$$ Open the new Lister in [[:basic_concepts:the_lister:dual_display|dual-display]] mode, laid out vertically.
``Go NEW=dualvert C:\ DUALPATH D:\``
$$
$$
$$ **nodual**
$$ Opens the new Lister in single-display mode.
``Go NEW=nodual``
$$
$$
$$ **viewpane**
$$ Displays the [[:basic_concepts:the_lister:viewer_pane|viewer pane]] in the new Lister.
``Go NEW=viewpane``
$$
$$
$$ **noviewpane**
$$ Does not display the viewer pane in the new Lister.
``Go NEW=noviewpane,notree``
$$
$$
$$ **findpanel**
$$ Displays the [[:basic_concepts:the_lister:utility_panel|utility panel]] in Find Files mode in the new Lister. The panel will open in its Simple or Advanced state, depending on which was used the last time the panel was closed.
``Go CURRENT NEW=findpanel``
$$
$$
$$ **findsimple**
$$ Displays the [[:basic_concepts:the_lister:utility_panel|utility panel]] in Find Files (Simple) mode in the new Lister.
``Go CURRENT NEW=findsimple``
$$
$$
$$ **findadvanced**
$$ Displays the [[:basic_concepts:the_lister:utility_panel|utility panel]] in Find Files (Advanced) mode in the new Lister.
``Go CURRENT NEW=findadvanced``
$$
$$
$$ **syncpanel**
$$ Displays the utility panel in Synchronize mode in the new Lister.
``Go {sourcepath} DUALPATH {destpath} NEW=syncpanel``
$$
$$
$$ **dupepanel**
$$ Displays the utility panel in Duplicate File Finder mode in the new Lister.
``Go {sourcepath} NEW=dupepanel``
$$
$$
$$ **noutilitypanel**
$$ Do not display the utility panel in the new Lister.
``Go NEW=noutilitypanel``
$$
$$
$$ **metapane**
$$ Displays the [[:basic_concepts:the_lister:metadata_pane|metadata pane]] in the new Lister.
``Go NEW=metapane``
$$
$$
$$ **nometapane**
$$ Does not display the metadata pane.
``Go NEW=nometapane,noutilitypanel,noviewpane,notree,nodual``
$$ NEWTAB
$$ /O
$$ //(no value)//
$$ Opens a new [[:basic_concepts:the_lister:tabs|folder tab]]. If no path is specified (e.g. via the **PATH** argument) then an empty tab is opened, otherwise the specified path will be loaded into the new tab. You can use the **TABPOS** argument to control where the newly-opened tab is positioned.
``Go C:\ NEWTAB``
$$
$$
$$ **deflister**
$$ If the command is run without a Lister then the Default Lister will open along with a new tab for the specified folder. If a Lister already exists then a new tab for the specified folder will open normally in the existing Lister.
``Go C:\ NEWTAB=deflister,findexisting``
$$
$$
$$ **dupe**
$$ Create the new tab as a duplicate of the existing tab (similar to `TABDUPLICATE=full`).
``Go NEWTAB=dupe``
$$
$$
$$ **findexisting**
$$ Look for the specified path in existing tabs. If found, the existing tab will be brought to the front; otherwise a new tab will be opened. The active tab is checked first, and nothing will happen if the active tab already displays the specified path.
``Go CURRENT NEWTAB=findexisting OPENINDUAL``
In some situations, **findexisting** is the default behavior, and **nofindexisting** can be used to suppress it.
$$
$$
$$ **findinactive**
$$ Like **findexisting**, except that if the active tab already has the specified path then a new tab will be opened. Intended for buttons which switch to existing tabs to reduce clutter while retaining the ability to open a second tab for the same folder when needed.
``Go "C:\Program Files" NEWTAB=findinactive``
$$
$$
$$ **nofindexisting**
$$ Explicitly suppresses the **findexisting** behavior described above. The default for most commands it to not look for existing tabs, but some (e.g. <nobr>`Go OPENCONTAINER NEWTAB`</nobr>) will look for existing tabs unless explicitly told not to.
``Go OPENCONTAINER NEWTAB=nofindexisting``
$$
$$
$$ **nofocus**
$$ The new tab will not be made active.
``Go CURRENT NEWTAB=nofocus``
$$
$$
$$ **tofront**
$$ Brings the Lister to the front. This is useful when opening a tab in another window.
``Go CURRENT NEWTAB=tofront OPENINDEST``
$$ NEXTCRUMB
$$ /S
$$ //(no value)//
$$ If the file display has a [[:basic_concepts:the_lister:navigation:breadcrumbs_location_field|breadcrumbs location field]] associated with it, and a ghost path is currently shown, this command will go to the next "crumb" in the ghost path.
``Go NEXTCRUMB``
$$ NOSCRIPT
$$ /S
$$ //(no value)//
$$ Allows a [[:scripting|script]] to run **Go** commands without triggering other scripts (or itself). Adding the **NOSCRIPT** argument disables the **[[..:..:scripting_reference:scripting_events:onbeforefolderchange|OnBeforeFolderChange]]**, **[[..:..:scripting_reference:scripting_events:onafterfolderchange|OnAfterFolderChange]]**, **[[..:..:scripting_reference:scripting_events:onopentab|OnOpenTab]]** and **[[..:..:scripting_reference:scripting_events:onopenlister|OnOpenLister]]** events that would otherwise be triggered by the command.
$$ OPENCONTAINER
$$ /O
$$ //(no value)//
$$ Opens the container (parent folder) of the selected item. In normal folders this is not that useful (since the parent of the selected item is the folder you're already in), but in [[:basic_concepts:virtual_file_system:file_collections|file collections]], [[:basic_concepts:virtual_file_system:libraries|libraries]] and [[:basic_concepts:flat_view|flat view]] it lets you quickly go to the actual folder where a file is located.
This command also works when multiple items are selected and may cause multiple windows or tabs to open if the selected items come from multiple containers.
This command is used on the default collection item context menu.
``Go OPENCONTAINER``
When combined with the **NEWTAB** argument, existing tabs are searched for automatically, without having to explicitly use **NEWTAB=findexisting**. If you want a new tab to open all the time, ignoring any existing tabs for the same folder, then you can use **NEWTAB=nofindexisting**.
``Go OPENCONTAINER NEWTAB=nofindexisting``
$$
$$
$$ **target**
$$ Dereferences a shortcut or junction. This is similar to the //Find Target// button in the system Properties dialog for shortcuts. When you run this command with a shortcut selected, the folder containing the target of the shortcut will be loaded and the target itself will be automatically selected (unless **noselect** is also given; see below). Similarly, if a junction is selected, you'll be taken the parent of its target and its target will be selected. If the selected item is neither a shortcut nor a junction then the command functions the same as if **target** had not been specified.
``Go OPENCONTAINER=target NEW``
$$
$$
$$ **noselect**
$$ Normally, the item or items in question are selected and made visible in the containing folder. Specifying this argument prevents the selection and just opens the containing folder.
``Go OPENCONTAINER=target,noselect NEWTAB``
$$ OPENINDEST
$$ /S
$$ //(no value)//
$$ The specified folder will be read into the destination file display. If the current Lister is not in dual-display mode, then it could mean the folder is read into another Lister altogether. You can combine this with **NEWTAB** to open tabs in the destination.
``Go CURRENT OPENINDEST``
$$ OPENINDUAL
$$ /O
$$ //(no value)//
$$ The specified folder will be read into the destination file display in a dual-display Lister. The difference between this argument and **OPENINDEST** is that this will force a single-display Lister into dual-display mode if it is not in that mode already. The default layout (horizontal or vertical) will be used in this case.
``Go CURRENT OPENINDUAL``
$$
$$
$$ **horiz**
$$ Force the layout of the dual-display Lister to horizontal (one display above the other).
``Go C:\Windows OPENINDUAL=horiz``
$$
$$
$$ **vert**
$$ Force the layout to vertical (side-by-side displays).
``Go CURRENT NEWTAB OPENINDUAL=vert``
$$ OPENINLEFT
$$ /S
$$ //(no value)//
$$ Reads the specified folder into the left-hand (or top) file display in a dual-display Lister. In a single-display Lister, this argument has no effect (the folder will be read into the single display as normal).
``Go {rightpath} OPENINLEFT``
$$ OPENINRIGHT
$$ /O
$$ //(no value)//
$$ Reads the specified folder into the right-hand (or bottom) file display in a dual-display Lister. If the current Lister is not already in dual-display mode it will be set to that mode automatically. The default layout (horizontal or vertical) will be used in this case.
``Go {leftpath} OPENINRIGHT``
$$
$$
$$ **horiz**
$$ Force the layout of the dual-display Lister to horizontal (one display above the other).
``Go C:\Windows OPENINRIGHT=horiz``
$$
$$
$$ **vert**
$$ Force the layout to vertical (side-by-side displays).
``Go {leftpath} NEWTAB OPENINRIGHT=vert``
$$ PATH
$$
$$ //(no value)//
$$ Specify the path to read (or in conjunction with the **FOLDERCONTENT** argument, the path to display the contents of).
Opus supports paths in many formats, for example:
* An absolute path like //C:\Windows//
* A relative path like ..\.. (goes up two levels from the current folder)
* A virtual filesystem [[:basic_concepts:virtual_file_system|URL-style path]] (e.g. //%%ftp://ftp.microsoft.com%%// or //%%lib://Documents%%//)
* An FTP [[:ftp:ftp_paths|address-book shortcut]] (e.g. //@MyFtpSite//)
* A [[:basic_concepts:the_lister:navigation:aliases|folder alias]] like ///mydocuments//
* An environment variable like //%USERPROFILE%//
* An [[..:external_control_codes|external control code]] like **{sourcepath}**
* A file URI like **file:%%//%%/C:/Temp**. This is the default argument for the **Go** command and so you do not need to specify the **PATH** keyword. Remember that if the path contains spaces it needs to be enclosed in quotes.
``Go "C:\Program Files\GPSoftware\Directory Opus"``
$$ PATHENTRY
$$ /O
$$ //(no value)//
$$ Displays the [[:basic_concepts:the_lister:find-as-you-type_field|find-as-you-type]] field in a special mode ("go" mode) that lets you navigate to another folder in the current file display. This command is equivalent to **[[cli|CLI]] QUICKGO**.
``Go PATHENTRY``
$$
$$
$$ **dest**
$$ The "Go" field will act on the destination file display rather than the source. Note that it will still appear at the bottom of the source file display, but once you press **Enter** the folder will be read into the destination.
``Go PATHENTRY=dest``
$$
$$
$$ **left**
$$ The "Go" field will act on the left-hand file display, whether it is the source or destination.
``Go PATHENTRY=left``
$$
$$
$$ **right**
$$ The "Go" field will act on the right-hand file display.
``Go PATHENTRY=right``
$$ REBUILDTREE
$$ /O
$$ //(no value)//
$$ Rebuilds the contents of the folder tree attached to the source file display. This is the equivalent of turning the tree off and then back on again.
``Go REBUILDTREE``
$$
$$
$$ **dest**
$$ Rebuilds the folder tree attached to the destination file display (when dual trees are enabled).
``Go REBUILDTREE=dest``
$$
$$
$$ **left**
$$ Rebuilds the folder tree attached to the left/top file display.
``Go REBUILDTREE=left``
$$
$$
$$ **right**
$$ Rebuilds the folder tree attached to the right/bottom file display (when dual trees are enabled).
``Go REBUILDTREE=right``
$$
$$
$$ **both**
$$ Rebuilds both folder trees (or the single tree, whichever is applicable).
``Go REBUILDTREE=both``
$$ REFRESH
$$ /O
$$ //(no value)//
$$ Refresh the display of the current folder in the source file display.
``Go REFRESH``
$$
$$
$$ **tree**
$$ Refresh the folder tree.
``Go REFRESH=tree``
$$
$$
$$ **both**
$$ Refresh both file displays in a dual-display Lister.
``Go REFRESH=both``
$$
$$
$$ **all**
$$ Refresh both file displays and folder trees.
``Go REFRESH=all``
$$
$$
$$ **source**
$$ Refresh the source file display and its tree.
``Go REFRESH=source``
$$
$$
$$ **dest**
$$ Refresh the destination file display and its tree.
``Go REFRESH=dest``
$$
$$
$$ **viewpane**
$$ Refresh the [[:basic_concepts:the_lister:viewer_pane|viewer pane]]. The image or file currently displayed in the pane will be reloaded.
``Go REFRESH=viewpane``
$$
$$
$$ **left**
$$ Refresh the left-hand file display.
``Go REFRESH=left``
$$
$$
$$ **right**
$$ Refresh the right-hand file display.
``Go REFRESH=right``
$$
$$
$$ **expanded**
$$ Preserves expanded folders when refreshing a file display. Overrides the Preferences setting.
``Go REFRESH=expanded``
$$
$$
$$ **noexpanded**
$$ Collapses expanded folders when refreshing a file display. Overrides the Preferences setting.
``Go REFRESH=both,noexpanded``
$$ REFRESHTHUMBS
$$ /O
$$ //(no value)//
$$ Refreshes thumbnails displayed in the current folder. If thumbnail caching is enabled the cache for the current folder is cleared, forcing thumbnails to be regenerated.
``Go REFRESHTHUMBS``
$$
$$
$$ **shift**
$$ Refreshes thumbnails only if the **Shift** key is held down. This lets you combine a normal folder refresh with a thumbnail refresh on the one command - it could perform an ordinary folder refresh by default, and also force the regeneration of thumbnails with the **Shift** key held down.
``Go REFRESH REFRESHTHUMBS=shift``
$$
$$
$$ **alt**
$$ Refresh thumbnails only if the **Alt** key is held down.
``Go REFRESHTHUMBS=alt``
$$
$$
$$ **ctrl**
$$ Refresh thumbnails only if the **Control** key is held down.
``Go REFRESHTHUMBS=ctrl REFRESH=all``
$$ REMEMBERTREEEXPANSION
$$ /O
$$ //(no value)//
$$ Remembers the current expansion state of the source folder tree. Once the state has been remembered, you can restore it later on with **RESTORETREEEXPANSION**.
By default the expansion state is just remembered for the lifetime of the Lister. If used with the **NAME** argument the expansion will be saved under that name and can be restored at any time in the future.
``Go REMEMBERTREEEXPANSION``
$$
$$
$$ **dest**
$$ Remembers the expansion state of the folder tree attached to the destination file display (when dual trees are enabled).
``Go REMEMBERTREEEXPANSION=dest``
$$
$$
$$ **left**
$$ Remembers the expansion state of the folder tree attached to the left/top file display.
``Go REMEMBERTREEEXPANSION=left``
$$
$$
$$ **right**
$$ Remembers the expansion state of the folder tree attached to the right/bottom file display (when dual trees are enabled).
``Go REMEMBERTREEEXPANSION=right``
$$
$$
$$ **both**
$$ Remembers the expansion state of both folder trees (or the single tree, whichever is applicable).
``Go REMEMBERTREEEXPANSION=both``
$$ RESTORETREEEXPANSION
$$ /O
$$ //(no value)//
$$ Restores the expansion state of the source folder tree that was previously remembered with **REMEMBERTREEEXPANSION**.
Combine with the **NAME** argument to restore a saved expansion.
``Go RESTORETREEEXPANSION NAME=CurrentJob``
$$
$$
$$ **dest**
$$ Restores the expansion state of the folder tree attached to the destination file display (when dual trees are enabled).
``Go RESTORETREEEXPANSION=dest``
$$
$$
$$ **left**
$$ Restores the expansion state of the folder tree attached to the left/top file display.
``Go RESTORETREEEXPANSION=left``
$$
$$
$$ **right**
$$ Restores the expansion state of the folder tree attached to the right/bottom file display (when dual trees are enabled).
``Go RESTORETREEEXPANSION=right``
$$
$$
$$ **both**
$$ Restores the expansion state of both folder trees (or the single tree, whichever is applicable).
``Go RESTORETREEEXPANSION=both``
$$
$$
$$ **reset**
$$ Resets the expansion of the tree to its initial state. Can be combined with the above keywords.
``Go RESTORETREEEXPANSION=both,reset``
$$ ROOT
$$ /O
$$ //(no value)//
$$ Navigate to the root of the current folder. For example, the root of //C:\Program Files\GPSoftware\Directory Opus// is //C://.
``Go ROOT``
$$
$$
$$ **collapse**
$$ Collapses the current drive's branch in the folder tree at the same time as navigating to the root folder.
``Go ROOT=collapse``
$$ RUNEMBEDDEDIFNOTFOUND
$$ /S
$$ //(no value)//
$$ This argument is used when [[:customize:creating_your_own_buttons:embedded_functions|embedding a function]] in the **Go FINDTITLE** command. Normally the embedded function will not be run if no Listers exist that match the supplied string. If the **RUNEMBEDDEDIFNOTFOUND** argument is specified, the embedded command will be run in the current Lister if a matching Lister is not found.
//Example://\\
<code>
Go FINDTITLE PhotoWork RUNEMBEDDEDIFNOTFOUND
[Set VIEW=Thumbnails]
</code>
$$ SWAP
$$ /S
$$ //(no value)//
$$ Swaps the folders displayed in the source and destination file displays.
``Go SWAP``
$$ SWITCHPATH
$$ /K/M
$$ //<alternate path> ...//
$$ Switches between (or cycles through) two or more paths. The **PATH** argument is used to provide the first path in the sequence, and then the **SWITCHPATH** argument provides the second and subsequent paths. When you run this command, Opus looks at the current path shown in the source file display. If it matches one of the provided paths, the next path in the sequence is read (and then the next, and then the next, and so on). If the current path does not match one of the provided ones the first path in the sequence is read.
``Go C:\ SWITCHPATH D:\ E:\ F:\ G:\``
$$ TABCLOSE
$$ /O
$$ //(no value)//
$$ Close the current [[:basic_concepts:the_lister:tabs|folder tab]] in the source file display.
You can combine this with the **PATH** argument to specify the path of a tab that should be closed. When used in this context the **PATH** argument can accept wildcards - all tabs matching the supplied pattern will be closed.
The **TABPOS** argument can be used to specify the index (starting from 0) of a specific tab to close, or position relative to the current tab, or the position of the first or last tab. (The **PATH** argument can also be given a specific tab index, but this usage is deprecated in favor of **TABPOS**.)
//Examples://
Close the current tab: `Go TABCLOSE`\\
Close all tabs showing a drive on C: `Go TABCLOSE PATH=C:\*`\\
Close the first tab: `Go TABCLOSE TABPOS=first`\\
Close the last tab: `Go TABCLOSE TABPOS=last`\\
Close the tab after the current tab: `Go TABCLOSE TABPOS=+1`\\
Close the tab before the current tab: `Go TABCLOSE TABPOS=-1`
When used from a [[:scripting|script]], you can pass the default value of a **[[..:..:scripting_reference:scripting_objects:tab|Tab]]** object to specify the tab you wish to close.
``Go TABCLOSE=<tab>``
$$
$$
$$ **left**
$$ Close a folder tab in the left (or top) file display, irrespective of whether it is the source or not.
``Go TABCLOSE=left``
$$
$$
$$ **right**
$$ Close a folder tab in the right (or bottom) file display.
``Go TABCLOSE=right TABPOS=-2``
$$
$$
$$ **dest**
$$ Close a folder tab in the destination file display.
``Go TABCLOSE=dest PATH=C:\*``
$$
$$
$$ **force**
$$ Close the folder tab even if it is locked and closing individual locked tabs is disabled in Preferences.
``Go TABCLOSE=force``
``Go TABCLOSE=dest,force``
$$ TABCLOSEALL
$$ /O
$$ //(no value)//
$$ Close all folder tabs except the current one.
When combined with the **TABGROUPLOAD** command, this overrides the tab group's //Close existing Folder Tabs// setting, and forces existing tabs to be closed.
``Go TABCLOSEALL``
$$
$$
$$ **left**
$$ Close all folder tabs to the left of the current tab.
``Go TABCLOSEALL=left``
$$
$$
$$ **right**
$$ Close all folder tabs to the right of the current tab.
``Go TABCLOSEALL=right``
$$
$$
$$ **dest**
$$ Lets you close tabs in the destination file display in a dual-display Lister.
``Go TABCLOSEALL=dest,right``
$$
$$
$$ **force**
$$ Forces locked tabs to be closed. Normally locked tabs are not closed by this command.
``Go TABCLOSEALL=right,force``
$$
$$
$$ **expand**
$$ Expands tabs to Listers. The tabs will be closed in the current Lister, and each folder opened as a new Lister.
``Go TABCLOSEALL=right,expand``
$$
$$
$$ **no**
$$ When combined with the **TABGROUPLOAD** command, this overrides the tab group's //Close existing Folder Tabs// setting, and forces existing tabs to be retained.
This value has no meaning when not used in conjunction with **TABGROUPLOAD**.
``Go TABGROUPLOAD=MyTabs TABCLOSEALL=no``
$$ TABCOLOR
$$ /K
$$ //<color>//
$$ Assigns a custom color to the current tab. You can specify the color in the decimal form R,G,B (e.g. 127,192,55) or the hex form #RRGGBB (e.g. #ff0033).
``Go TABCOLOR #ff8000``
$$
$$
$$ **reset**
$$ Resets the current tab's color.
``Go TABCOLOR=reset``
$$
$$
$$ **edit**
$$ Initiates editing of the current tab's color. You can use the **PATH** argument to specify the index of a tab to edit (with the left-most being index #0).
``Go TABCOLOR=edit``
$$ TABDUPLICATE
$$ /O
$$ //(no value)//
$$ Duplicates the current folder tab.
``Go TABDUPLICATE``
$$
$$
$$ **active**
$$ Makes the new tab active.
``Go TABDUPLICATE=active``
$$
$$
$$ **dual**
$$ Creates a duplicate of the current folder tab in the other file display of a dual-display Lister.
``Go TABDUPLICATE=dual``
$$
$$
$$ **full**
$$ Creates a full duplicate including file selections and sub-folder expansion.
``Go TABDUPLICATE=full``
$$
$$
$$ **nocolor**
$$ Doesn't copy the tab's color settings when the duplicate is made.
``Go TABDUPLICATE=dual,nocolor``
$$
$$
$$ **nolock**
$$ Doesn't copy the tab's lock state when the duplicate is made.
``Go TABDUPLICATE=full,nolock``
$$ TABGROUPDESC
$$ /K
$$ //<description>//
$$ When saving a tab group programmatically using `Go TABGROUPSAVE`, this lets you assign a description to the tab group at the same time.
``Go TABGROUPSAVE=MyTabs TABGROUPDESC="All my lovely tabs"``
$$ TABFINDEXISTING
$$ /S
$$ //(no value)//
$$ If the specified folder is open in another tab Opus will switch to that tab, otherwise the folder will be read into the current tab. Enables similar behavior to the **NEWTAB=findexisting** argument, except that a new tab is not opened if the path is not found.
``Go /mydocuments TABFINDEXISTING``
$$ TABGROUPFORCE
$$ /S
$$ //(no value)//
$$ Use in conjunction with the **TABGROUPLOAD** or **TABGROUPLIST** arguments to force folders in the loaded tabs to load immediately even if they would normally be blocked by the Auto-Loading settings on the [[:preferences:preferences_categories:folders:automatic_reading|Automatic Reading]] page in Preferences.
``Go TABGROUPLOAD "My Tab Group" TABGROUPFORCE``
$$ TABGROUPLIST
$$ /O
$$ //(no value)//
$$ Displays a list of your saved [[:basic_concepts:the_lister:tabs:tab_groups|Folder Tab Groups]] (acts as a [[:customize:creating_your_own_buttons:editing_the_toolbar:dynamic_buttons|dynamic button]]). Selecting a group from the list will open those tabs in the current file display.
This argument works when used in conjunction with the **USEQUALKEYS**, **TABGROUPFORCE** and **KEYARGS** arguments.
``Go TABGROUPLIST``
$$
$$
$$ **keys**
$$ Assigns the accelerator keys **0** through **9** to the first ten items displayed on the generated tab group list.
``Go TABGROUPLIST=keys USEQUALKEYS``
$$
$$
$$ **icons**
$$ Displays icons for items on the generated tab group list.
``Go TABGROUPLIST=keys,icons``
$$
$$
$$ **nohighlight**
$$ Prevents the active tab group from being highlighted.
``Go TABGROUPLIST=icons,nohighlight``
$$
$$
$$ **savecurrent**
$$ Saves the current folder tab group (if any) before loading a new one. Without this, any changes to a tab group will be lost when loading another one, unless you explicitly save them.
As a special case, clicking the button for the current tab group will reload that group without first saving over it, giving you a way to reset to the group's last saved state.
If no tab group is currently loaded, nothing will be saved before loading the new tab group.
``Go TABGROUPLIST=savecurrent``
Note that if you want Opus to save tab groups automatically in this way, you may also want to add something to trigger **Go TABGROUPSAVE=!current,!quiet** when listers close, or on other events such as opening/closing tabs or changing folders, depending on when you want the tab group to be updated. This probably also only makes sense if you only use one lister, since multiple listers may have differnet views of the currently open groups and save over each other. But if you want auto-saving tab groups, you're probably already using a single window all the time, as other people would use separate windows for separate tab groups and switch between windows instead of switching groups in a single window.
$$ TABGROUPLOAD
$$ /K
$$ //<group name>//
$$ Loads the named folder tab group. This can be combined with **OPENINDUAL** etc. to open the tab group in another file display. You can also combine the **TABCLOSEALL** argument to override the tab group's //Close existing Folder Tabs// setting.
``Go TABGROUPLOAD "My Tab Group" TABCLOSEALL=no``
$$ TABGROUPSAVE
$$ /O
$$ //(no value)//
$$ Save the current set of folder tabs as a new tab group. You will be prompted to provide a name for the group.
``Go TABGROUPSAVE``
$$
$$
$$ //<group name>//
$$ Save the current set of folder tabs using the specified group name.
``Go TABGROUPSAVE "My Tab Group"``
$$
$$
$$ **!both**
$$ In a dual-display Lister, this will save the tabs from both file displays to a single group using the "specific sides" option. You can also specify a group name by following the keyword with a comma. (The group name, if any, must come after the keyword and not before.)
``Go TABGROUPSAVE="!both,My Tab Group"``
$$
$$
$$ **!closeall**
$$ Saves the tab group such that it will close all existing tabs when it is loaded (unless overridden at the time of loading). If neither **!closeall** nor **!nocloseall** are specified, saving over an existing group will preserved its mode, new groups created non-interactively will close existing tabs by default, and new groups created interactively will default to the mode used the last time the interactive dialog was displayed. (The group name, if any, must come after the keyword and not before.)
``Go TABGROUPSAVE="!both,!closeall,My Tab Group"``
$$
$$
$$ **!nocloseall**
$$ Saves the tab group such that it will not close any existing tabs when it is loaded (unless overridden at the time of loading). See **!closeall**, above, for more information. (The group name, if any, must come after the keyword and not before.)
``Go TABGROUPSAVE="!both,!nocloseall,My Tab Group"``
$$
$$
$$ **!current**
$$ Saves over the folder tab group which was last loaded. The **!both** keyword is ignored, and instead the mode is inherited from the existing group. Add the **!quiet** keyword to make the command do nothing if there is no current tab group to save over; otherwise you will be prompted for the name of a new group in that situation.
``Go TABGROUPSAVE="!current"``
$$
$$
$$ **!quiet**
$$ Combine **!quiet** with **!current** to prevent being asked to name a new tab group if there isn't one to save over.
``Go TABGROUPSAVE="!current,!quiet"``
$$
$$
$$ **!unless**
$$ Combine **!unless** with **!current** to tell the command to save the current group unless it has a particular name. You probably won't need to use this directly, but it is how the **Go TABGROUPLIST=savecurrent** command avoids saving over the current group if you click its button to reload it.
``Go TABGROUPSAVE="!current,!quiet,!unless,My Tab Group"``
$$
$$
$$ **!forget**
$$ Tells the file display to forget the name of the last tab group it loaded. Combine with **!both** to make both sides of a dual-display lister forget. You may wish to use this if you load a tab group and then modify it to the point that it no longer has any connection to the original group, and you do not want it to remain selected in any tab group lists.
``Go TABGROUPSAVE="!forget"``
$$ TABLINK
$$ /K
$$ **on**
$$ In a dual-display Lister, links the current active tab in the source file display with the current active tab in the destination file display.
``Go TABLINK=on``
$$
$$
$$ **off**
$$ If the currently active tab is linked, this will unlink it.
``Go TABLINK=off``
$$
$$
$$ **toggle**
$$ Toggles tab linking on or off for the currently active tabs in both left and right file displays.
``Go TABLINK=toggle``
$$
$$
$$ **navlock**
$$ Use in conjunction with **on** or **toggle** to specify that the tab is to be linked in [[:basic_concepts:the_lister:dual_display:navigation_lock|navigation lock]] mode (so that it follows the other tab whenever the folder is changed).
``Go TABLINK=toggle,navlock``
$$
$$
$$ reset
$$ When two tabs are linked in navigation lock mode, the reset keyword lets you reset the sync position to the current locations (for recovering when they get out of sync).
``Go TABLINK=reset``
$$
$$
$$ **unlinkall**
$$ Unlinks all linked tabs in the current Lister.
``Go TABLINK=unlinkall``
$$
$$
$$ //<tab1>,<tab2>//
$$ When used from a [[:scripting|script]], you can pass the default value of two **[[..:..:scripting_reference:scripting_objects:tab|Tab]]** objects to specify the precise tabs you wish to link. The two values must be comma-separated. If only one **[[..:..:scripting_reference:scripting_objects:tab|Tab]]** object is specified, it will be unlinked if it is currently linked.
``Go TABLINK=<tab1>,<tab2>,navlock``
$$
$$
$$ **menu**
$$ Generates the standard tab link menu. This is included on the default folder tab [[:customize:the_customize_dialog:context_menus|context menu]].
``Go TABLINK=menu``
$$ TABLIST
$$ /O
$$ //(no value)//
$$ Displays a list of the currently open folder tabs (acts as a [[:customize:creating_your_own_buttons:editing_the_toolbar:dynamic_buttons|dynamic button]]). Selecting a tab from the list will switch to that tab. You can also drag and drop files to the items in the list to copy them to that tab's folder.
By default the tabs shown are those from the current source file display, but you can combine with the **OPENINLEFT**, **OPENINRIGHT** and **OPENINDEST** arguments to display tabs from other file displays.
``Go TABLIST``
$$
$$
$$ **keys**
$$ Assigns the accelerator keys **0** through **9** to the first ten items displayed on the generated tab list.
``Go TABLIST=keys``
$$
$$
$$ **sort**
$$ Sorts the tab list alphabetically (without this, the items in the list are listed in the same order as the physical tabs). The sort order is based on the folder name (or tab label).
``Go TABLIST=sort,keys``
$$
$$
$$ **sortpath**
$$ Sorts the tab list alphabetically, based on the full path of each folder.
``Go TABLIST=sortpath``
$$
$$
$$ **icons**
$$ Displays folder icons for each tab in the list.
``Go TABLIST=sortpath,icons``
$$
$$
$$ **namesonly**
$$ Only displays the folder name for each tab rather than the full path. Does not affect tabs which use custom labels; custom labels are always displayed as-is.
``Go TABLIST=sort,namesonly``
$$
$$
$$ **maxwidth=**//<width>//
$$ Specifies a maximum width (in characters) for each item in the list. When showing the full path of each tab, you may want to use this to stop the tab list from being too wide. If not specified, a maximum width of 50 is used by default - you can disable this (and have no maximum width at all) by specifying **maxwidth=0**.
Note that because this parameter requires an equals sign, you must enclose the whole value of the **TABLIST** argument in quotes.
``Go TABLIST="keys,maxwidth=70"``
$$ TABLOCK
$$ /K
$$ **lock**
$$ Lock the current [[:basic_concepts:the_lister:tabs|folder tab]] to prevent any folder changes. Attempts to change the folder will result in a new tab being created.
``Go TABLOCK=lock``
$$
$$
$$ **lockchanges**
$$ Lock the current tab. Folder changes will be allowed, but the tab will revert to its original (locked) directory if it is clicked, or if the focus is moved to another tab and then back to this one. You can also use the command **Go TABLOCKDIR** to revert to the original directory.
``Go TABLOCK=lockchanges``
$$
$$
$$ **lockreuse**
$$ Lock the current tab. Attempts to change folder will result in the first already existing, unlocked tab being used to read the new directory. A new tab will be opened if there are no unlocked tabs that can be used.
``Go TABLOCK=lockreuse``
$$
$$
$$ **off**
$$ Unlock the current folder tab.
``Go TABLOCK=off``
$$
$$
$$ **toggle**
$$ Combine with the various **lock** keywords to toggle that lock mode on or off.
``Go TABLOCK=lockchanges,toggle``
$$
$$
$$ **all**
$$ Lock or unlock all folder tabs.
``Go TABLOCK=lock,all``
$$
$$
$$ **left**
$$ Lock or unlock all tabs to the left of the current tab.
``Go TABLOCK=lockchanges,toggle,left``
$$
$$
$$ **right**
$$ Lock or unlock all tabs to the right of the current tab.
``Go TABLOCK=off,right``
$$
$$
$$ **target**
$$ (Opus 13.9.1 and above.) For use with scripting. Acts on the Command object's tab rather than the currently active tab.
``Go TABLOCK=off,target``
$$
$$
$$ **menu**
$$ Generates the standard tab lock menu. This is included on the default folder tab [[:customize:the_customize_dialog:context_menus|context menu]].
``Go TABLOCK=menu``
$$ TABLOCKDIR
$$ /S
$$ //(no value)//
$$ Indicates the original (locked) directory of the current folder tab. This is the directory that was shown in the tab when it was set to 'Lock Allow Changes' mode. You can use this to return to the locked folder, or open it in another tab or Lister. If the current tab is not locked this argument behaves the same as the **CURRENT** argument.
``Go TABLOCKDIR``
$$ TABMOVE
$$ /O
$$ //(no value)//
$$ Move the current folder tab to the other file display. (See **TABPOS** for repositioning tabs without changing sides.) The Lister will be set to dual-display mode if it's not in that mode already.
``Go TABMOVE``
$$
$$
$$ **split**
$$ Splits the folder tabs currently open in a single-display Lister. The Lister will be set to dual-display mode, and all tabs from the current tab onwards will be moved to the other display. If the Lister is already in dual-display mode this command has no effect.
``Go TABMOVE=split``
$$
$$
$$ **splitlister**
$$ Splits the folder tabs in the current file display to a new Lister. All tabs from the current tab onwards will be closed in the current display, and reopened in a new Lister.
``Go TABMOVE=splitlister``
$$
$$
$$ //<new position>//
$$ Specify the new position for the moved tab. You can specify an absolute position, **-1** to indicate the same relative position, and **-2** to position the moved tab to the right of the currently active tab. If not specified, the moved tab will be positioned at the end of all existing tabs.
``Go TABMOVE=-2``
$$
$$
$$ **active**
$$ If specified, the moved tab will be made active. Otherwise the previously active tab in the other file display remains active.
``Go TABMOVE=active,-2``
$$ TABNAME
$$ /O
$$ //(no value)//
$$ Clears the name of the current tab if one has been assigned. This will reset the tab label back to the default which is to show the name of the current folder.
``Go TABNAME``
$$
$$
$$ <//tab name//>
$$ Assigns the specified name to the current tab. If combined with the **NEWTAB** argument the name will be assigned to the newly created tab.
``Go C:\Work NEWTAB TABNAME "My Work Dir"``
You can use several special "tokens" in the tab name to insert various pieces of information:
|**%P**|full path of the current (source) folder|
|**%N**|name of the current (source) folder|
|**%R**|drive root of the current (source) folder|
|**%!**|hide section|
``Go TABNAME "%R - %N"``
The **%!** code lets you hide sections in the string where all other tokens inside the section are empty.
``Go TABNAME "%!Drive %R : %!%N"``
That means that if the **%R** token expands to an empty string, the result will be just "%N" (the name of the folder).
$$
$$
$$ **!edit**
$$ Initiates editing of the current tab's name. You can use the **PATH** argument to specify the index of a tab to edit (with the left-most being index #0).
``Go TABNAME=!edit``
$$ TABPOS
$$ /K
$$ **first**
$$ When used with the **NEWTAB** argument, causes the newly created tab to appear as the first on the tab bar. When used with **TABCLOSE**, closes the first tab. When used on its own, repositions the active folder tab so it is first on the tab bar.
``Go C:\ NEWTAB TABPOS=first``
When used from a [[:scripting|script]], you can pass the default value of a **[[..:..:scripting_reference:scripting_objects:tab|Tab]]** object to specify the tab you wish to reposition as the second parameter.
``Go TABPOS=first,<tab>``
$$
$$
$$ **last**
$$ When used with the **NEWTAB** argument, causes the newly created tab to appear as the last on the tab bar. When used with **TABCLOSE**, closes the last tab. When used on its own, repositions the active folder tab so it is last on the tab bar.
``Go TABPOS=last``
When used from a [[:scripting|script]], you can pass the default value of a **[[..:..:scripting_reference:scripting_objects:tab|Tab]]** object to specify the tab you wish to reposition as the second parameter.
``Go TABPOS=last,<tab>``
$$
$$
$$ **+1**
$$ When used with the **NEWTAB** argument, causes the newly created tab to appear as to the right of the currently active tab. When used with **TABCLOSE**, closes the tab to the right of the active tab. When used on its own, repositions the active folder tab to the right of its current position on the tab bar. You can also use +2 for two positions to the right, and so on.
``Go TABPOS=+1``
When used from a [[:scripting|script]], you can pass the default value of a **[[..:..:scripting_reference:scripting_objects:tab|Tab]]** object to specify the tab you wish to reposition as the second parameter.
``Go TABPOS=+3,<tab>``
$$
$$
$$ **-1**
$$ When used with the **NEWTAB** argument, causes the newly created tab to appear to the left of the currently active tab. When used with **TABCLOSE**, closes the tab to the left of the active tab. When used on its own, repositions the active folder tab to the left of its current position on the tab bar. You can also use -2 for two positions to the left, and so on.
``Go TABPOS=-1``
When used from a [[:scripting|script]], you can pass the default value of a **[[..:..:scripting_reference:scripting_objects:tab|Tab]]** object to specify the tab you wish to reposition as the second parameter.
``Go TABPOS=-2,<tab>``
$$
$$
$$ //<index>//
$$ When used with the **NEWTAB** argument, specifies the position for the newly created tab. When used with **TABCLOSE**, specifies the position of the tab to close. When used on its own, repositions the active folder tab to a specific place on the tab bar. 0 is the first tab (you can also use "first"), 1 the second, 2 the third, and so on.
``Go D:\ NEWTAB TABPOS=2``
When used from a [[:scripting|script]], you can pass the default value of a **[[..:..:scripting_reference:scripting_objects:tab|Tab]]** object to specify the tab you wish to reposition as the second parameter.
``Go TABPOS=3,<tab>``
$$ TABSCROLL
$$ /O
$$ //(no value)//
$$ If there are more tabs open than will fit in the display, this command displays the tab overflow menu (useful if you want to bind this to a hotkey). You can combine this with the **OPENINDEST**, **OPENINLEFT** and **OPENINRIGHT** arguments to display the overflow menu in other file displays.
``Go TABSCROLL``
$$
$$
$$ //<delta>//
$$ Scroll the folder tabs left or right if there are more tabs open than will fit in the display.
``Go TABSCROLL=-1``
$$ TABSELECT
$$ /K
$$ **first**
$$ Select (make active) the first folder tab in the current file display.
``Go TABSELECT=first``
$$
$$
$$ **last**
$$ Select the last folder tab in the current file display.
``Go TABSELECT=last``
$$
$$
$$ **prev**
$$ Reselect the previously selected folder tab.
``Go TABSELECT=prev``
$$
$$
$$ **+1**
$$ Select the next folder tab.
``Go TABSELECT +1``
$$
$$
$$ **-1**
$$ Select the previous folder tab.
``Go TABSELECT -1``
$$
$$
$$ **home**
$$ Resets a locked tab to its "home" directory. This is equivalent to **Go TABLOCKDIR**. If the current tab is not set to 'Locked Allow Changes' mode this command has no effect.
``Go TABSELECT home``
$$
$$
$$ //<index>//
$$ Select a specific folder tab. The index is 0 relative (so **Go TABSELECT 0** is equivalent to **Go TABSELECT first**).
``Go TABSELECT=5``
$$
$$
$$ $//<tab>//
$$ Select a specific folder tab from a script. If you have a **[[..:..:scripting_reference:scripting_objects:tab|Tab]]** object and want to activate it, add it to the command string prefixed by a **$** character.
``cmd.RunCommand("Go TABSELECT=$" + tab)``
$$ TABSWAP
$$ /O
$$ //(no value)//
$$ Swaps the active tab in the left file display with the active tab in the right file display.
``Go TABSWAP``
$$
$$
$$ //<index1>//,//<index2>//
$$ Specify indices to swap a specific tab from the left file display with a specific tab in the right file display.
``Go TABSWAP=0,0``
$$ TABSWITCHER
$$ /S
$$ //(no value)//
$$ Displays the "tab switcher", a popup list of tabs open in the current Lister. You can use it to switch to another tab in the same way Alt+Tab in Windows lets you switch to another window.
By default the tab switcher is bound to the Ctrl+Tab key; you can use this command to bind it to a different key or trigger it via a mouse button, etc.
``Go TABSWITCHER``
$$ TABUNDOCLOSE
$$ /S
$$ //(no value)//
$$ Undoes the last action that resulted in one or more tabs being closed.
``Go TABUNDOCLOSE``
$$ TITLE
$$ /K
$$ //<custom title>//
$$ Specifies a custom title when opening a new Lister using the **NEW** argument. You can use several special "tokens" in the title string to insert various pieces of information:
|**%P**|full path of the current (source) folder|
|**%N**|name of the current (source) folder|
|**%R**|drive root of the current (source) folder|
|**%D**|full path of the destination folder|
|**%M**|name of the destination folder|
|**%G**|target if the folder is a junction or softlink|
|**%1**|full path in the left file display|
|**%2**|full path in the right file display|
|**%3**|folder name in the left file display|
|**%4**|folder name in the right file display|
|**%L**|name of the Layout the Lister came from (if any)|
|**%S**|name of the current Style selected in the Lister (if any)|
|**%T**|complete original title (useful for simply adding a prefix or suffix)|
|**%!**|hide section|
``Go NEW TITLE "Directory Opus - %N"``
The **%!** code lets you hide sections in the string where all other tokens inside the section are empty.
``Go NEW TITLE "%!%T - %!Directory Opus"``
That means that if the **%T** token expands to an empty string, the result will be just "Directory Opus" rather than " - Directory Opus".
$$ TOFRONT
$$ /S
$$ //(no value)//
$$ Makes the Lister the active window and brings it to the front. Typically used when sending commands from outside of Opus, to make sure the window that reads the folder is visible.
``Go C:\ TOFRONT``
$$ TREECOLLAPSE
$$ /O
$$ //(no value)//
$$ Collapses the selected branch in the tree belonging to the source file display.
``Go TREECOLLAPSE``
$$ $$ $$ **dest**
$$ Collapses the selected branch in the tree belonging to the destination file display (when dual trees are enabled).
``Go TREECOLLAPSE=dest``
$$ $$ $$ **left**
$$ Collapses the selected branch in the left/top file display.
``Go TREECOLLAPSE=left``
$$ $$ $$ **right**
$$ Collapses the selected branch in the right/bottom file display (when dual trees are enabled).
``Go TREECOLLAPSE=right``
$$ $$ $$ **both**
$$ Collapses the selected branches in both source and destination trees.
``Go TREECOLLAPSE=both``
$$ $$ $$ **focus**
$$ Collapses the selected branches in the tree which currently has input focus (or the tree belonging to the file display with input focus).
``Go TREECOLLAPSE=focus``
$$ $$ $$ **all**
$$ Collapse all folders (and all their child folders, and so on) below the selected folder, not just the selected folder.
``Go TREECOLLAPSE=all,both``
$$ $$ $$ **first**
$$ Collapse just the first level of descendants below the selected folder.
``Go TREECOLLAPSE=left,first``
$$ $$ $$ **second**
$$ Collapse the first and second levels of descendants below the selected folder.
``Go TREECOLLAPSE=second``
$$ TREEEXPAND
$$ /O
$$ //(no value)//
$$ When used in conjunction with reading a folder, this command automatically expands the folder tree to display the contents of the new folder. This is only of use if the **Automatically expand to current folder** option on the **[[:preferences:preferences_categories:folder_tree:expand_collapse|Folder Tree / Expand / Collapse]]** Preferences page is turned off.
You can also use this command by itself, to expand the currently selected folder.
``Go "C:\Program Files\GPSoftware\Directory Opus" NEW TREEEXPAND``
$$ $$ $$ **dest**
$$ Expands the selected branch in the tree belonging to the destination file display (when dual trees are enabled).
``Go TREEEXPAND=dest``
$$ $$ $$ **left**
$$ Expands the selected branch in the left/top file display.
``Go TREEEXPAND=left``
$$ $$ $$ **right**
$$ Expands the selected branch in the right/bottom file display (when dual trees are enabled).
``Go TREEEXPAND=right``
$$ $$ $$ **both**
$$ Expands the selected branches in both source and destination trees.
``Go TREEEXPAND=both``
$$ $$ $$ **focus**
$$ Expands the selected branches in the tree which currently has input focus (or the tree belonging to the file display with input focus).
``Go TREEEXPAND=focus``
$$ $$ $$ **all**
$$ Expand all folders (and all their child folders, and so on) below the selected folder, not just the selected folder.
``Go TREEEXPAND=all,both``
$$ $$ $$ **first**
$$ Expand just the first level of descendants below the selected folder.
``Go TREEEXPAND=left,first``
$$ $$ $$ **second**
$$ Expand the first and second levels of descendants below the selected folder.
``Go TREEEXPAND=second``
$$ TREESETPINSTATE
$$ /O
$$ //(no value)//
$$ Toggles the "pin" state of the currently selected folder in the [[basic_concepts:the_lister:navigation:folder_tree|folder tree]]. Pinned folders always stay expanded - they can't be collapsed. Note that folder pinning needs to be enabled from the [[preferences:preferences_categories:folder_tree:expand_collapse:pins]] page in Preferences for this command to have any effect.
``Go TREESETPINSTATE``
$$
$$
$$ **on**
$$ Turns on the "pin" state of the currently selected folder.
``Go TREESETPINSTATE=on``
$$
$$
$$ **off**
$$ Turns off the "pin" state of the currently selected folder.
``Go TREESETPINSTATE=off``
$$ UNDOCLOSELISTER
$$ /O
$$ //(no value)//
$$ Reopens the last Lister that was closed (so if, for example, you accidentally close the Lister you're working with, this command would bring it back).
``Go UNDOCLOSELISTER``
$$
$$
$$ **closeexisting**
$$ Reopens the last Lister that was closed, and closes all other open Listers.
``Go UNDOCLOSELISTER=closeexisting``
$$ UP
$$ /S
$$ //(no value)//
$$ Navigate [[:basic_concepts:the_lister:navigation:up_forwards_back|up]] to the parent of the current folder. You can combine this with **OPENINDUAL** etc. to open the parent of the current folder in another file display or Lister. This can also be combined with the **BACK** argument - in that case, if the parent of the current folder is also the previous folder in the history list, Opus will move back rather than up - preserving the file selection and other state of the previous folder.
``Go UP``
$$ USEQUALKEYS
$$ /S
$$ //(no value)//
$$ Activates pre-configured behaviour for the main qualifier keys - **Control** will open the folder in the dual-display, **Shift** in a new Lister and **Alt** in a new tab.
This is equivalent to **KEYARGS ctrl:OPENINDUAL shift:NEW alt:NEWTAB**.
``Go C:\ USEQUALKEYS``
$$ USER
$$ /K
$$ //<user name>//
$$ Can be used when certain folder aliases are supplied for the **PATH** argument. This lets you specify an alternative user name, to access a specific user's instance of a system folder (providing you have the appropriate permissions, of course). If the specified alias doesn't support multiple users this argument has no effect.
``Go /desktopdir USER="Leo Nudelson"``
$$ VIEW
$$ /K
$$ **largeicons**
$$ Changes the [[:basic_concepts:the_lister:view_modes|view mode]] of the new folder to //Large Icons// mode.
``Go CURRENT NEWTAB VIEW=largeicons``
$$
$$
$$ **smallicons**
$$ Changes the view mode of the new folder to //Small Icons// mode.
``Go C:\ VIEW smallicons``
$$
$$
$$ **list**
$$ Changes the view mode to //List// mode.
``Go {destpath} VIEW list``
$$
$$
$$ **details**
$$ Changes the view mode to //Details// mode.
``Go CURRENT LAYOUT=PhotoLayout VIEW=details``
$$
$$
$$ **power**
$$ Changes the view mode to //Power// mode.
``Go NEW VIEW=power``
$$
$$
$$ **thumbnails**
$$ Changes the view mode to //Thumbnails// mode.
``Go /desktop VIEW=thumbnails``
$$
$$
$$ **tiles**
$$ Changes the view mode to //Tiles// mode.
``Go @WorkFTP NEWTAB VIEW tiles``
$$ WHENDUAL
$$ /K
$$ **checkmouse**
$$ This works in conjunction with the **BACK**, **FORWARD** and **UP** arguments and is designed to be used with "app command" hotkeys like the Back button on a mouse. It lets you make navigation commands triggered from the mouse act on the file display underneath the mouse pointer in a dual display Lister, rather than, as is the default, the source file display.
``Go BACK WHENDUAL=checkmouse``
$$
$$ r
$$ **anydevice**
$$ Use with the **checkmouse** argument to cause the **WHENDUAL** argument to activate when the command is run from a non-mouse device (e.g. when the command is bound to a **Back** button on a keyboard).
``Go BACK WHENDUAL=checkmouse,anydevice``
$$
$$
$$ **deffocus**
$$ Add the deffocus argument to cause the command to fall back to the original behavior if the mouse pointer isn't currently over either of the file displays.
``Go BACK WHENDUAL=checkmouse,deffocus``
</commandtable2>