User Defined Commands - External Commands

External Commands provide seamless integration between Multi Commander and any external application or system utility by launching programs with dynamically generated parameters. This powerful command type transforms Multi Commander into a comprehensive workflow hub that can pass file paths, selections, and contextual information to external tools, creating automated workflows that span multiple applications.

External Application Integration

Launch any Windows application or system utility with dynamic parameters using MultiTags that automatically inject file paths, selections, and contextual information. External Commands bridge Multi Commander with your complete toolchain, enabling sophisticated workflows that process files through external editors, converters, analyzers, and specialized utilities with a single command execution.

External Commands Overview

External Commands serve as the bridge between Multi Commander and the broader Windows application ecosystem, enabling you to launch any program with contextual file information and custom parameters for integrated workflow automation.

How External Commands Work
Command Execution Process
  • Program Selection: Specify the external application to launch
  • Parameter Definition: Define command line arguments using MultiTags
  • MultiTag Processing: Multi Commander replaces tags with dynamic values
  • Command Execution: Launch application with processed parameters
  • Context Awareness: Commands receive current file selections and paths
  • Dynamic Values: Parameters adapt to current Multi Commander state
  • Security Options: Run with elevated privileges when required
  • User Confirmation: Optional confirmation dialogs for safety
Integration Capabilities
  • File Processing: Pass selected files to external editors, converters, or analyzers
  • Development Tools: Launch IDEs, compilers, and development utilities with project files
  • System Utilities: Execute system tools with specific files or directories
  • Custom Applications: Integrate proprietary or specialized software into workflows
Workflow Integration

External Commands transform Multi Commander into a central hub for file-based workflows, eliminating the need to manually switch between applications and copy file paths.

Key Benefits
Workflow Efficiency
  • Seamless Integration: Launch any application directly from Multi Commander
  • Context Preservation: External programs receive current file context automatically
  • Parameter Automation: Eliminate manual parameter entry and file path copying
  • Consistent Interface: Access external tools through familiar Multi Commander interface
Flexibility
  • Any Application: Works with any Windows executable or system utility
  • Dynamic Parameters: Command line arguments adapt to current selections
  • Security Options: Run applications with appropriate privilege levels
  • User Control: Optional confirmation dialogs for sensitive operations
Common Applications
Development Workflows
  • Code Editors: Open files in Visual Studio Code, Notepad++, or other editors
  • Version Control: Launch Git clients with repository paths
  • Build Tools: Execute compilers or build systems with project files
  • Development Utilities: Run linters, formatters, or analysis tools
Content Processing
  • Image Processing: Open images in specialized editors or converters
  • Document Tools: Launch document processors with specific files
  • Media Applications: Open audio/video files in appropriate players or editors
  • System Tools: Execute system utilities with targeted files or folders

Configuring External Commands

Setting up External Commands involves specifying the target application and defining command line parameters using MultiTags that provide dynamic file and context information.

Configuration Interface
External Commands Configuration

The External Commands configuration interface showing program path and parameter fields

Configuration Fields
Program Path
  • Executable Path: Full path to the external application
  • System Programs: Use program names for system PATH applications
  • Browse Button: Use file browser to locate applications
  • Environment Variables: Use variables like %PROGRAMFILES%
Working Directory
  • Startup Location: Directory where application starts
  • Dynamic Paths: Use MultiTags for context-based directories
  • Default Behavior: Empty field uses application's default
Command Parameters
  • Arguments: Command line parameters passed to application
  • MultiTag Integration: Use tags for dynamic file and path information
  • Static Parameters: Include fixed arguments and switches
  • Parameter Order: Arrange arguments according to application requirements
Advanced Options
  • Security Settings: Run as administrator when required
  • User Confirmation: Display confirmation dialogs
  • File Drop Support: Accept files dropped onto command buttons
  • Parameter Passing: Support command line and scripting parameter input
Setup Process
Step-by-Step Configuration
  1. Select External Commands: Choose "External Commands" as the command type
  2. Specify Program: Enter the full path to the external application or use system program name
  3. Define Parameters: Create command line arguments using MultiTags and static values
  4. Set Working Directory: Optionally specify startup directory using paths or MultiTags
  5. Configure Options: Set security, confirmation, and advanced options as needed
  6. Test Command: Verify the command works with test files and selections
  7. Assign Access: Create buttons, hotkeys, or menu items for the command
Path Quoting

MultiTags don't include quotes by default. When file paths might contain spaces, wrap MultiTags in quotes: "${focusfilepath}"

MultiTags for Dynamic Parameters

MultiTags are specially formatted placeholders that Multi Commander replaces with dynamic information such as file paths, selections, and contextual data when executing External Commands.

Essential MultiTags Reference
MultiTag Description Example Value
${focusfilepath} Full path to the file currently in focus C:\Documents\report.txt
${focusfilename} Name of the file currently in focus report.txt
${sourcepath} Path of the current source panel C:\Documents\
${targetpath} Path of the current target panel D:\Backup\
${selectedfiles} All selected files separated by spaces file1.txt file2.txt file3.txt
${selectedfilepaths} Full paths of all selected files C:\Docs\file1.txt C:\Docs\file2.txt
MultiTag Usage Guidelines
  • Quoting: Wrap MultiTags in quotes when paths may contain spaces
  • Multiple Files: Use appropriate tags for single vs. multiple file operations
  • Path Consistency: Ensure target application expects the path format provided
  • Empty Values: Consider what happens when tags resolve to empty values
  • Parameter Order: Place MultiTags in command line according to application requirements
  • Mixed Parameters: Combine MultiTags with static parameters as needed
  • Testing: Verify MultiTag resolution with different file selections
  • Documentation: Reference complete MultiTags documentation for all available tags
Parameter Examples
Single File Operations
"${focusfilepath}"

Opens the focused file in the external application.

Multiple File Processing
"${selectedfilepaths}"

Passes all selected files as separate parameters.

Directory Operations
--input "${sourcepath}" --output "${targetpath}"

Uses source and target paths as named parameters.

Advanced Parameter Scenarios
Application-Specific Parameters
-f "${focusfilepath}" -o "${targetpath}output.txt"

Combines file input with specified output location.

Command Line Parameter Support
"${param:0}" "${selectedfilepaths}"

Uses parameter passed from command line or scripts.

Complex Mixed Parameters
--batch --input "${sourcepath}" --format jpg "${selectedfiles}"

Combines static options with dynamic file information.

Command Options and Security

External Commands provide advanced options for security, user interaction, and parameter handling to ensure safe and flexible integration with external applications.

Security and Execution Options
External Command Options

Available options for controlling External Command execution behavior

Run as Administrator
  • Elevated Privileges: Launch application with administrator rights
  • UAC Integration: Triggers User Account Control dialog when needed
  • System Access: Required for applications that modify system files or settings
  • Platform Support: Available on Windows Vista and later (not XP/2003)
Display Confirmation
  • Safety Check: Shows confirmation dialog before command execution
  • Accidental Prevention: Prevents unintended command execution
  • Command Review: Allows users to see what will be executed
  • Recommended Use: For commands that modify files or system state
Use Dropped Files as Parameters
  • Drag-and-Drop Support: Accept files dropped onto command buttons
  • Dynamic Parameters: Dropped files become command parameters
  • Parameter Access: Use ${param:<num>} MultiTags for dropped files
  • Interactive Workflows: Enable file processing through drag-and-drop operations
Command Arguments Support
  • Parameter Passing: Accept arguments from command line or scripts
  • Flexible Input: Support both static and dynamic parameter sources
  • Integration Ready: Work with Custom Commands and MultiScript
  • Parameterized Access: Use numbered parameter tags for flexible input
Security Considerations
When to Use Administrator Mode
  • System File Access: Applications that modify system files or registry
  • Service Management: Tools that start/stop Windows services
  • Driver Installation: Software installation or hardware configuration
  • Protected Locations: Access to protected system directories
Security Best Practices
  • Minimal Privileges: Only use administrator mode when absolutely necessary
  • Confirmation Dialogs: Enable for potentially destructive operations
  • Trusted Applications: Only configure commands for trusted external programs
  • Parameter Validation: Ensure MultiTags resolve to expected values
Drag-and-Drop Integration
Setting Up File Drop Support
  1. Enable Option: Check "Use Dropped Files as Parameters"
  2. Configure Parameters: Use ${param:0}, ${param:1}, etc.
  3. Create Button: Assign command to a button panel button
  4. Test Drop: Drag files onto the button to verify functionality
Parameter Access Pattern
  • ${param:0}: First dropped file
  • ${param:1}: Second dropped file
  • ${param:n}: nth dropped file
  • Combined Use: Mix dropped files with MultiTags and static parameters

Practical External Command Examples

These real-world examples demonstrate how External Commands can integrate various applications and tools into your Multi Commander workflow for enhanced productivity.

Development Tools
Visual Studio Code
Program: code
Parameters: "${focusfilepath}"
Description: Open focused file in VS Code
Git Client (SourceTree)
Program: C:\Program Files\SourceTree\SourceTree.exe
Parameters: -f "${sourcepath}"
Description: Open repository in SourceTree
Command Line Compiler
Program: gcc
Parameters: -o "${targetpath}output.exe" "${focusfilepath}"
Description: Compile focused C file to target directory
Content Processing
Image Editor (GIMP)
Program: C:\Program Files\GIMP 2\bin\gimp-2.10.exe
Parameters: "${selectedfilepaths}"
Description: Open selected images in GIMP
PDF Viewer
Program: C:\Program Files\Adobe\Acrobat DC\Acrobat\Acrobat.exe
Parameters: /A "page=1" "${focusfilepath}"
Description: Open PDF at first page
Media Player
Program: C:\Program Files\VideoLAN\VLC\vlc.exe
Parameters: --intf qt "${selectedfilepaths}"
Description: Play selected media files in VLC
System Utilities
Windows PowerShell
Program: powershell.exe
Parameters: -NoExit -Command "Set-Location '${sourcepath}'"
Description: Open PowerShell in current directory
File Checksum Utility
Program: certutil
Parameters: -hashfile "${focusfilepath}" MD5
Description: Calculate MD5 hash of focused file
System File Checker
Program: sfc
Parameters: /scannow
Options: Run as Administrator ✓
Description: Run system file checker
File Conversion
Image Format Converter
Program: magick
Parameters: convert "${focusfilepath}" "${targetpath}${focusfilename}.jpg"
Description: Convert image to JPG in target directory
Document Converter
Program: pandoc
Parameters: -f markdown -t html "${focusfilepath}" -o "${targetpath}output.html"
Description: Convert Markdown to HTML
Archive Creation
Program: 7z
Parameters: a "${targetpath}archive.7z" "${selectedfilepaths}"
Description: Create 7z archive of selected files
Advanced: Drag-and-Drop Example
Image Batch Processor with Drop Support
Configuration
  • Program: C:\Tools\ImageProcessor.exe
  • Parameters: --batch --format png --output "${targetpath}" "${param:0}" "${param:1}" "${param:2}"
  • Options: Use Dropped Files as Parameters ✓
  • Assignment: Create button named "Convert to PNG"
Usage
  1. Set Target: Navigate target panel to output directory
  2. Drag Files: Drag image files onto the "Convert to PNG" button
  3. Automatic Processing: External tool processes files with target directory
  4. Result: Converted PNG files appear in target directory
Workflow Benefits

This approach eliminates the need to manually specify input and output paths, creating a streamlined drag-and-drop workflow for batch file processing.

External Commands Mastery

Master External Commands by understanding MultiTag capabilities for dynamic parameter generation, using appropriate security options for different applications, and creating logical button assignments for drag-and-drop workflows. Remember to quote MultiTags when file paths may contain spaces, use confirmation dialogs for potentially destructive operations, and test commands with various file selections to ensure reliable operation. External Commands transform Multi Commander into a powerful integration hub for your entire application ecosystem.

Related Documentation

Enhance your External Commands knowledge with: User Defined Commands Overview, Complete MultiTags Reference, Internal Commands, Custom Commands, Batch Scripts, MultiScript, and Button Editor for interface integration.