# Copy

The **Copy** internal command can be used to:

* Copy and move files and folders
* Create and add files to archives
* Extract files from archives
* Perform simple one-way file synchronization
* Create links, shortcuts and junctions
* Install fonts
* Send files via email
* Add items to [file collections](../../../basic_concepts/virtual_file_system/file_collections), and include folders in [libraries](../../../basic_concepts/virtual_file_system/libraries)

**Command Arguments:**

| Argument          | Type | Possible values           | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| ----------------- | ---- | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| ADDTOARCHIVE      | /O   | _(no value)_              | <p>Displays the <a href="../../../file_operations/creating_archives/add_to_archive_dialog"><strong>Add to Archive</strong></a> dialog, to create an archive from the selected files. The dialog will default to creating a Zip file.</p><p><em>Example:</em> <code>Copy ADDTOARCHIVE</code></p><p>The <strong>CREATEFOLDER</strong> argument can be used to change the default archive name.</p><p><em>Example:</em> <code>Copy ADDTOARCHIVE CREATEFOLDER="Backup"</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                   |      | _\<archive format>_       | <p>Displays the <a href="../../../file_operations/creating_archives/add_to_archive_dialog"><strong>Add to Archive</strong></a> dialog with the archive type set to the specified format (given as the file extension of the desired format).</p><p><em>Example:</em> <code>Copy ADDTOARCHIVE=.rar</code></p><p>The archive format can be optionally followed by parameters that are specific to the selected format. Currently the only format that defines optional parameters is Zip, those are listed below.</p><p><em>Example:</em> <code>Copy ADDTOARCHIVE=.zip,fullpaths</code></p><p>You can also use this command to create a self-extracting archive from the selected files, with the following arguments:</p><p><em>Example:</em> <code>Copy ADDTOARCHIVE=.zip+sfx</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|                   |      | **fullpaths**             | <p>When creating Zip archives, this turns on the <em>Save full file paths</em> option by default.</p><p><em>Example:</em> <code>Copy ADDTOARCHIVE=.zip,fullpaths</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|                   |      | **nofullpaths**           | <p>When creating Zip archives, this disables the <em>Save full file paths</em> option.</p><p><em>Example:</em> <code>Copy ADDTOARCHIVE=.zip,nofullpaths</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|                   |      | **keepfolder**            | <p>Modifies the behaviour when only a single folder is selected - instead of the items within the folder being added, the folder itself will be added to the archive.</p><p><em>Example:</em> <code>Copy ADDTOARCHIVE=.zip,keepfolder</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|                   |      | **nokeepfolder**          | <p>Adds the contents of the folder when only a single folder is selected.</p><p><em>Example:</em> <code>Copy ADDTOARCHIVE=.zip,nokeepfolder</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                   |      | **comp:**_\<compression>_ | <p>Specifies the compression level when creating Zip archives. You can use one of the keywords <strong>store</strong>, <strong>fastest</strong>, <strong>fast</strong>, <strong>normal</strong>, <strong>good</strong> and <strong>best</strong>, or provide a number from 0 to 19. Numbers 10 and above enable enhanced compression; otherwise the <strong>enhanced</strong> or <strong>noenhanced</strong> keywords can also be used to override the default.</p><p><em>Example:</em> <code>Copy ADDTOARCHIVE=.zip,comp:best,enhanced</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|                   |      | **split:**_\<size>_       | <p>When creating Zip archives, this sets the default value for the <em>Split archive</em> option.</p><p><em>Example:</em> <code>Copy ADDTOARCHIVE=.zip,fullpaths,split:2.5MB</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
|                   |      | **nosplit**               | <p>When creating Zip archives, this disables the <em>Split archive</em> option.</p><p><em>Example:</em> <code>Copy ADDTOARCHIVE=.zip,nosplit,nofullpaths</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| ARCHIVE           | /O   | _(no value)_              | <p>Adds all selected files and folders to a Zip file named after the first selected item. Note that if only a single folder is selected, the items <em>within</em> that folder are added rather than the folder itself - this prevents you from ending up with a Zip file containing an unnecessary sub-folder.</p><p><em>Example:</em> <code>Copy ARCHIVE</code></p><p>The <strong>CREATEFOLDER</strong> argument can be used to change the default archive name.</p><p><em>Example:</em> <code>Copy ARCHIVE CREATEFOLDER="Backup"</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|                   |      | _\<archive format>_       | <p>Adds all selected files and folders to an archive of the specified format. The archive format can be optionally followed by parameters that are specific to the selected format - see <strong>ADDTOARCHIVE</strong> above for a list of these.</p><p><em>Example:</em> <code>Copy ARCHIVE=.rar</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|                   |      | **single**                | <p>Each selected item will be added to its own archive, rather than all items being added to the one archive.</p><p><em>Example:</em> <code>Copy ARCHIVE=single</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|                   |      | **keepfolder**            | <p>Modifies the behaviour when only a single folder is selected - instead of the items within the folder being added, the folder itself will be added to the archive.</p><p><em>Example:</em> <code>Copy ARCHIVE=keepfolder</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                   |      | **nokeepfolder**          | <p>Adds the contents of the folder when only a single folder is selected.</p><p><em>Example:</em> <code>Copy ARCHIVE=nokeepfolder</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| AS                | /O   | _(no value)_              | <p>When copying or moving files, you will be prompted to enter a new name for each file.</p><p><em>Example:</em> <code>Copy MOVE AS</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|                   |      | _\<new name>_             | <p>Specifies the new name or <a href="../../../file_operations/copying_moving_and_deleting_files/copying_using_the_toolbar_buttons/using_wildcards_when_copying">wildcard pattern</a> for the copied or moved files. This only changes the names; if you want to specify the destination path, use the <strong>TO</strong> argument.</p><p><em>Example:</em> <code>Copy AS *.bak HERE</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| AUTOSELECT        | /K   | **yes**                   | <p>Overrides the state of the <em>Automatically select newly copied files</em> option on the <a href="../../../preferences/preferences_categories/file_operations/copying_files"><strong>Copying Files</strong></a> Preferences page. Newly copied files will always be selected.</p><p><em>Example:</em> <code>Copy DUPLICATE AUTOSELECT=yes</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|                   |      | **no**                    | <p>Newly copied files will not be selected, no matter what the <em>Automatically select newly copied files</em> option is set to.</p><p><em>Example:</em> <code>Copy AUTOSELECT=no</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| BUFSIZE           | /K/N | _\<size in bytes>_        | <p>Overrides the <strong>copy_buffer_size</strong> setting on the <a href="../../../preferences/preferences_categories/miscellaneous/advanced_options"><strong>Miscellaneous / Advanced</strong></a> page in Preferences. The buffer size is specified in bytes, if no units are specified, and you can also use KB, MB and GB to specify larger sizes.</p><p>This buffer is in addition to any buffering provided by the filesystem, hardware, and so on; it is not connected to the non-buffered IO mode controlled by the <strong>NONBUFIO</strong> argument and <strong>copy_nonbufferio_threshold</strong> Preferences option.</p><p><em>Example:</em> <code>Copy BUFSIZE 128KB</code></p><p>This has no effect when doing simple file-to-file copies and delegating to the very-high-level Windows file-copy API, since that API performs its own buffering. See the <strong>DELEGATE</strong> argument for more detail.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| BURNCD            | /S   | _(no value)_              | <p>Invokes the system CD Burning Wizard, which initiates burning of any files you have previously copied to the CD staging area.</p><p><em>Example:</em> <code>Copy BURNCD</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| CLEARREADONLY     | /K   | **yes**                   | <p>Clear the read-only attribute. When copying files from a CD this overrides the <strong>Clear read-only flag when copying from CDs</strong> option on the <a href="../../../preferences/preferences_categories/file_operations/copying_files/attributes"><strong>Copying Files / Attributes</strong></a> Preferences page.</p><p><em>Example:</em> <code>Copy CLEARREADONLY=yes</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|                   |      | **no**                    | <p>Do not clear the read-only flag when copying files.</p><p><em>Example:</em> <code>Copy CLEARREADONLY=no</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| COLLLIST          | /S   | _(no value)_              | <p>Displays a dynamically generated list of <a href="../../../basic_concepts/virtual_file_system/file_collections">file collections</a> - you can add selected files and folders to a file collection simply by selecting it from this list. Acts as a <a href="../../../customize/creating_your_own_buttons/editing_the_toolbar/dynamic_buttons">dynamic button</a>. Most useful when used in a drop-down menu or on a <a href="../../../file_types/filetype_editor/context_menu">context menu</a>.</p><p><em>Example:</em> <code>Copy COLLLIST</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| COPYATTR          | /K   | **yes**                   | <p>Preserves file attributes when copying files or folders.</p><p>Overrides the <strong>Copy file attributes</strong> option on the <a href="../../../preferences/preferences_categories/file_operations/copying_files/attributes"><strong>Copying Files / Attributes</strong></a> Preferences page.</p><p><em>Example:</em> <code>Copy COPYATTR=yes</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|                   |      | **no**                    | <p>Do not preserve file attributes (the newly copied file will have the default file attributes for a newly created file).</p><p><em>Example:</em> <code>Copy COPYATTR=no</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| COPYDESC          | /K   | **yes**                   | <p>Preserves file descriptions when copying files or folders, when the descriptions are not stored within NTFS ADS or when NTFS ADS is not otherwise being copied.</p><p>Overrides the <strong>Copy file descriptions (if not in ADS, or not already copying ADS)</strong> option on the <a href="../../../preferences/preferences_categories/file_operations/copying_files/attributes"><strong>Copying Files / Attributes</strong></a> Preferences page, where the option and NTFS ADS are described in detail.</p><p><em>Example:</em> <code>Copy COPYDESC=yes</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|                   |      | **no**                    | <p>Do not preserve file descriptions beyond what may be done if NTFS ADS are being copied.</p><p><em>Example:</em> <code>Copy COPYDESC=no</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| COPYDIRTIMES      | /K   | **all**                   | <p>Preserves the Modified and Created timestamps of copied folders.</p><p>Overrides the <strong>Copy timestamps</strong> option on the <a href="../../../preferences/preferences_categories/file_operations/copying_files/attributes"><strong>Copying Files / Attributes</strong></a> Preferences page and the <strong>no_copy_dir_dates</strong> option on the <a href="../../../preferences/preferences_categories/miscellaneous/advanced_options"><strong>Miscellaneous / Advanced</strong></a> Preferences page.</p><p><em>Example:</em> <code>Copy COPYDIRTIMES=all</code></p><p>In all cases, the Accessed timestamp is handled the same as the Modified timestamp. Accessed timestamps are not mentioned explicitly because they are a legacy feature of Windows that are not usually worth thinking about.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                   |      | **none**                  | <p>Prevents preservation of the Modified and Created timestamps of copied folders; instead, the timestamps will be reset to the date and time the copy is made.</p><p><em>Example:</em> <code>Copy COPYDIRTIMES=none</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|                   |      | **onlymodified**          | <p>Preserves the Modified timestamps while preventing preservation of the Created timestamps of copied folders.</p><p><em>Example:</em> <code>Copy COPYDIRTIMES=onlymodified</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
|                   |      | **onlycreated**           | <p>Preserves the Created timestamps while preventing preservation of the Modified timestamps of copied folders.</p><p><em>Example:</em> <code>Copy COPYDIRTIMES=onlycreated</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| COPYFILETIMES     | /K   | **all**                   | <p>Preserves the Modified and Created timestamps of copied files.</p><p>Overrides the <strong>Copy timestamps</strong> option on the <a href="../../../preferences/preferences_categories/file_operations/copying_files/attributes"><strong>Copying Files / Attributes</strong></a> Preferences page.</p><p><em>Example:</em> <code>Copy COPYFILETIMES=all</code></p><p>In all cases, the Accessed timestamp is handled the same as the Modified timestamp. Accessed timestamps are not mentioned explicitly because they are a legacy feature of Windows that are not usually worth thinking about.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|                   |      | **none**                  | <p>Prevents preservation of the Modified and Created timestamps of copied files; instead, the timestamps will be reset to the date and time the copy is made.</p><p><em>Example:</em> <code>Copy COPYFILETIMES=none</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|                   |      | **onlymodified**          | <p>Preserves the Modified timestamps while preventing preservation of the Created timestamps of copied files.</p><p><em>Example:</em> <code>Copy COPYFILETIMES=onlymodified</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                   |      | **onlycreated**           | <p>Preserves the Created timestamps while preventing preservation of the Modified timestamps of copied files.</p><p><em>Example:</em> <code>Copy COPYFILETIMES=onlycreated</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| COPYOWNER         | /K   | **local**                 | <p>Copy file owner information, when the copy takes place between local drives only.</p><p>Overrides the <strong>Copy owner</strong> and subordinate <strong>Local drives only</strong> options on the <a href="../../../preferences/preferences_categories/file_operations/copying_files/attributes"><strong>Copying Files / Attributes</strong></a> Preferences page.</p><p>Note that setting the file owner requires elevation and may produce a UAC prompt.</p><p><em>Example:</em> <code>Copy COPYOWNER=local</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                   |      | **all**                   | <p>Copy file owner information for all drives, not just local ones.</p><p><em>Example:</em> <code>Copy COPYOWNER=all</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|                   |      | **no**                    | <p>Do not copy file owner information.</p><p><em>Example:</em> <code>Copy COPYOWNER=no</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| COPYPROPERTIES    | /K   | **yes**                   | <p>Always copy NTFS ADS properties/metadata when copying files and folders.</p><p>Overrides the <strong>Copy NTFS ADS</strong> option on the <a href="../../../preferences/preferences_categories/file_operations/copying_files/attributes"><strong>Copying Files / Attributes</strong></a> Preferences page, where the three options are explained in detail.</p><p><em>Example:</em> <code>Copy COPYPROPERTIES=yes</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|                   |      | **no**                    | <p>Always remove NTFS ADS metadata when copying files.</p><p><em>Example:</em> <code>Copy COPYPROPERTIES=no</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                   |      | **fastest**               | <p>Copy NTFS ADS metadata when copying files, unless it is slower to do so.</p><p><em>Example:</em> <code>Copy COPYPROPERTIES=fastest</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| COPYSECURITY      | /K   | **yes**                   | <p>Copy security permissions when copying files between NTFS drives.</p><p>Overrides the <strong>Copy security permissions</strong> option on the <a href="../../../preferences/preferences_categories/file_operations/copying_files/attributes"><strong>Copying Files / Attributes</strong></a> Preferences page.</p><p><em>Example:</em> <code>Copy COPYSECURITY=yes</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|                   |      | **no**                    | <p>Do not copy security permissions. Newly copied files will inherit the default security permissions of the destination folders.</p><p><em>Example:</em> <code>Copy COPYSECURITY=no</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| COPYSPARSE        | /K   | **yes**                   | <p>Recreate sparse regions in the copied file (when the source file is sparse).</p><p>Overrides the <strong>Copy sparse files as sparse</strong> option on the <a href="../../../preferences/preferences_categories/file_operations/copying_files/attributes"><strong>Copying Files / Attributes</strong></a> Preferences page.</p><p><em>Example:</em> <code>Copy COPYSPARSE=yes</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|                   |      | **no**                    | <p>Do not recreate sparse regions in the copied file. Newly copied files will occupy their full size on disk.</p><p><em>Example:</em> <code>Copy COPYSPARSE=no</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| COPYTOCOLL        | /K   | **member**                | <p>When copying (adding) folders to a <a href="../../../basic_concepts/virtual_file_system/file_collections">file collection</a>, add them as members of the collection (overrides the <strong>When copying folders to a Collection</strong> option on the <a href="../../../preferences/preferences_categories/file_operations/copying_files/confirmation"><strong>Copying Files / Confirmation</strong></a> Preferences page).</p><p><em>Example:</em> <code>Copy COPYTOCOLL=member</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|                   |      | **sub**                   | <p>Copy folders to collections as sub-collections (the contents of the folder will be added as member items to the newly created sub-collection).</p><p><em>Example:</em> <code>Copy COPYTOCOLL=sub</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|                   |      | **ask**                   | <p>Ask how to copy folders to collections.</p><p><em>Example:</em> <code>Copy COPYTOCOLL=ask</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| CREATEFOLDER      | /O   | _(no value)_              | <p>Prompts for the name of a new folder and copies the selected files and folders into that folder.</p><p><em>Example:</em> <code>Copy CREATEFOLDER</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|                   |      | _\<folder name>_          | <p>Creates a new folder with the specified name and copies selected items into that folder. You can specify an absolute path, or just a name - if only a name is provided the folder is created in the destination (or source if the <strong>HERE</strong> argument is also specified). You can also use the <a href="../external_control_codes">external control codes</a> to (for example) automatically create a folder based on the current date.</p><p><em>Example:</em> <code>Copy CREATEFOLDER "Backup-{date|yyyyMMdd}"</code></p><p>When archiving files, this specifies the name of the archive to create or update. (If you don't specify an archive name it will default to the name of the first selected file, without its extension, or the name of the current folder if no file selection is used.). The example below adds the selected files to an archive called "Cat Photos.zip" below the current folder:</p><p><em>Example:</em> <code>Copy HERE ARCHIVE=.zip CREATEFOLDER="Cat Photos"</code></p>                                                                                                                                                                                                                                                                                                                                           |
| DELEGATE          | /K   | **yes**                   | Overrides the **copy\_allow\_delegation** setting on the [**Miscellaneous / Advanced**](../../../preferences/preferences_categories/miscellaneous/advanced_options) page in Preferences. Delegation to the very-high-level Windows file-copying API will be allowed, and custom file-copying code will only be used when required. (This is the normal behavior. Specifying **DELEGATE=yes** is redundant unless you have changed the default Preferences setting and want a particular command to revert back to normal.)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|                   |      | **no**                    | <p>Overrides the <strong>copy_allow_delegation</strong> setting the opposite way: Custom file-copying code will always be used, even when it is not required. (Not recommended outside of very special cases.)</p><p><em>Example:</em> <code>Copy DELEGATE=no</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| DUPLICATE         | /S   | _(no value)_              | <p>Create duplicates of the selected items in the same folder. You will be prompted to enter new names (or a <a href="../../../file_operations/copying_moving_and_deleting_files/copying_using_the_toolbar_buttons/using_wildcards_when_copying">wildcard pattern</a>) for the duplicated files.</p><p><em>Example:</em> <code>Copy DUPLICATE</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| EXTRACT           | /O   | _(no value)_              | <p>Extracts the contents of selected archives to the destination folder. You can also use this with folders to copy their contents without copying the folder itself.</p><p><em>Example:</em> <code>Copy EXTRACT</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|                   |      | **sub**                   | <p>Creates a sub-folder in the destination named after the archive, and extracts the archive contents to that folder.</p><p><em>Example:</em> <code>Copy EXTRACT=sub</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|                   |      | **checkout**              | <p>Extracts the contents of an archive to a temporary folder and automatically opens that folder in a new Lister. You can use this to "check out" the files in an archive before you decide if and where you want to extract them to. Note that this command only works when you are inside the archive itself (e.g. double-click a .zip file to enter it, and then run the "checkout" command to extract it).</p><p><em>Example:</em> <code>Copy EXTRACT=checkout</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| FILE              | /M   | _\<filename> ..._         | <p>Specifies the name of the file or files to copy. If you don't provide this argument the command operates on all selected items in the source Lister. This is the default argument for the <strong>Copy</strong> command - you don't need to specify the <strong>FILE</strong> keyword.</p><p>If you only specify the filename instead of the full path of the file or files, Opus will look in the current source folder. You can also specify a <a href="../../wildcard_reference/pattern_matching_syntax">wildcard pattern</a>. Remember that if the filename contains spaces you need to enclose it in quotes.</p><p><em>Example:</em> <code>Copy "C:\Data Directory\\.xls" TO /desktop</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| FILTER            | /O   | _(no value)_              | <p>Copies with filtering enabled (without having to activate the <a href="../../../file_operations/filtered_operations">copy filter</a> in the Lister first). Opus will prompt you to define the filter.</p><p><em>Example:</em> <code>Copy FILTER</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                   |      | _\<filter>_               | <p>Copies using the specified filter. This must have previously been created from the <a href="../../../preferences/preferences_categories/filtering_and_sorting/filters"><strong>Filters</strong></a> page in Preferences. You can also directly specify a <a href="../../wildcard_reference/pattern_matching_syntax">simple wildcard pattern</a></p><p><em>Example:</em> <code>Copy FILTER *.(jpg|png)</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
|                   |      | **shift**                 | <p>Copies with filtering enabled if the <strong>Shift</strong> key is held down. Opus will prompt you to define the filter.</p><p><em>Example:</em> <code>Copy FILTER=shift</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                   |      | **alt**                   | <p>Copies with filtering enabled if the <strong>Alt</strong> key is held down.</p><p><em>Example:</em> <code>Copy FILTER=alt</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
|                   |      | **ctrl**                  | <p>Copies with filtering enabled if the <strong>Ctrl</strong> key is held down.</p><p><em>Example:</em> <code>Copy FILTER=ctrl</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| FILTERDEF         | /K/R | _\<filter>_               | <p>Lets you define a filter in <a href="../../../file_operations/filtered_operations/textual_filters">text format</a> to filter the contents of copied folders. This is similar to the <strong>FILTER</strong> argument, however the filter does not need to be predefined.</p><p>This is a <strong>/R</strong> argument and so everything after the <strong>FILTERDEF</strong> keyword will be treated as the argument's value.</p><p><em>Example:</em> <code>Copy FILTERDEF name match *.zip and size match > 2 mb</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| FLATVIEWCOPY      | /K   | **single**                | <p>When copying items in different directories from a <a href="../../../basic_concepts/flat_view">flat view</a> file display, the files will all be copied to the same target directory. This overrides the <strong>When copying nested items</strong> option on the <a href="../../../preferences/preferences_categories/file_operations/copying_files/confirmation"><strong>Copying Files / Confirmation</strong></a> Preferences page.</p><p><em>Example:</em> <code>Copy FLATVIEWCOPY=single</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|                   |      | **recreate**              | <p>Recreates the source folder structure when copying items in different directories out of a <a href="../../../basic_concepts/flat_view">flat view</a> file display.</p><p><em>Example:</em> <code>Copy FLATVIEWCOPY=recreate</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
|                   |      | **ask**                   | <p>Opus will ask you what to do when copying items out of a flat view file display.</p><p><em>Example:</em> <code>Copy FLATVIEWCOPY=ask</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|                   |      | **autosingle**            | <p>When used with <strong>ask</strong> or <strong>recreate</strong> this specifies what to do when the items being copied come from multiple folders. If the items being copied all come from the same folder, it will act as if <strong>single</strong> was specified instead.</p><p><em>Example:</em> <code>Copy FLATVIEWCOPY=autosingle,recreate</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| FORCE             | /S   | _(no value)_              | <p>Automatically replace existing files without prompting. In-use files that cannot be replaced will be automatically scheduled for replacement next reboot.</p><p><em>Example:</em> <code>Copy FORCE</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| HERE              | /S   | _(no value)_              | <p>Use the source folder as the destination folder (for example, archives can be extracted to the same folder instead of the destination).</p><p><em>Example:</em> <code>Copy EXTRACT HERE</code></p><p><strong>Important:</strong> The <strong>HERE</strong> argument can complicate buttons which run more than one command, as it can affect the destination folder used by subsequent commands in the same button. It is recommended to use <strong>TO={sourcepath$}</strong> instead if the button runs multiple commands.</p><p><strong>Scripting:</strong> The <strong>HERE</strong> argument does not work when running commands via the scripting Command object. Instead, use <em>cmd.SetDestTab(cmd.sourcetab)</em> on the Command object, or use an explicit <strong>TO</strong> argument in the command string.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| IGNOREEXT         | /S   | _(no value)_              | <p>Makes the copy function ignore file extensions when copying with a wildcard rename (for example, so a button can work on both files and folders using the same wildcard pattern).</p><p><em>Example:</em> <code>Copy * AS *.bak IGNOREEXT</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| INCLUDEINLIBRARY  | /O   | _(no value)_              | <p>Displays a dynamically generated list of <a href="../../../basic_concepts/virtual_file_system/libraries">libraries</a> - you can include a selected folder in a library simply by selecting it from this list. Acts as a <a href="../../../customize/creating_your_own_buttons/editing_the_toolbar/dynamic_buttons">dynamic button</a>. Most useful when used in a drop-down menu or on a <a href="../../../file_types/filetype_editor/context_menu">context menu</a>.</p><p>Opus will automatically navigate to show the contents of the library with the newly included folder.</p><p><em>Example:</em> <code>Copy INCLUDEINLIBRARY</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
|                   |      | **noread**                | <p>Prevents Opus from automatically navigating to the library when you include a folder in it via the generated list.</p><p><em>Example:</em> <code>Copy INCLUDEINLIBRARY noread</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|                   |      | **$new**                  | <p>Include selected folders in a new library. The new library will be given the name of the first selected folder. Opus will automatically navigate to the new library unless you include the <strong>noread:</strong> prefix.</p><p><em>Example:</em> <code>Copy INCLUDEINLIBRARY noread:\$new</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|                   |      | _\<library name>_         | <p>Include selected folders in the named library. Opus will automatically navigate to the new library unless you include the <strong>noread:</strong> prefix.</p><p><em>Example:</em> <code>Copy INCLUDEINLIBRARY "noread:Movie Files"</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| INSTALLFONT       | /O   | _(no value)_              | <p>Installs new fonts in your system fonts folder. You do not need to specify the destination folder when using this command - the fonts will be copied to your fonts folder and registered automatically. This command has no effect if non-font files are selected. Fonts will be installed for all users (and so elevation will be required if UAC is enabled).</p><p><em>Example:</em> <code>Copy INSTALLFONT</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|                   |      | **user**                  | <p>Installs the new fonts for the current user only. Does not require elevation under UAC.</p><p><em>Example:</em> <code>Copy INSTALLFONT=user</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| MAKELINK          | /O   | _(no value)_              | <p>Creates shortcuts to all selected files and folders. Shortcuts do not require NTFS. Shortcuts may point to things on different drives to themselves.</p><p><em>Example:</em> <code>Copy MAKELINK TO /desktop</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|                   |      | **junction**              | <p>Creates junctions to all selected folders. Junctions are only supported on NTFS drives. Junctions only work with folders (not with files). Junctions may point to folders on different drives to themselves.</p><p><em>Example:</em> <code>Copy MAKELINK=junction</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|                   |      | **hardlink**              | <p>Creates hardlinks to all selected files. Hardlinks are only supported on NTFS drives. Hardlinks only work with files (not folders). Hardlinks <em>cannot</em> point to files on different drives to themselves.</p><p><em>Example:</em> <code>Copy MAKELINK=hardlink</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|                   |      | **softlink**              | <p>Creates softlinks to all selected files or folders, using absolute paths. Softlinks require Windows Vista or above and are only supported on NTFS drives. Softlinks work with both files and folders. Softlinks may point to things on different drives to themselves. Creating softlinks requires administrator access and will trigger a UAC prompt if necessary.</p><p><em>Example:</em> <code>Copy MAKELINK=softlink</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                   |      | **relsoftlink**           | <p>Creates softlinks to any selected files or folders, using relative paths where possible. A regular absolute link will be created if the target can not be expressed relative to the link. (See <strong>softlink</strong> for more information on softlinks.)</p><p><em>Example:</em> <code>Copy MAKELINK=relsoftlink</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|                   |      | **auto**                  | <p>Automatically determines the most suitable type of link to create. On Vista and above, it will usually create softlinks (for both files and folders). On Windows XP, it will usually create junctions (for folders) and hardlinks (for files). Shortcuts will be created instead in cases where the desired link type is not applicable. For example, a shortcut will be created if the drives are not NTFS or if a hardlink is desired but the source and destination are on different drives.</p><p><em>Example:</em> <code>Copy MAKELINK=auto</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|                   |      | **autonosoft**            | <p>Does the same as <strong>auto</strong> except that it will not try to create softlinks. It will usually create junctions (for folders) and hardlinks (for files). Shortcuts will be created instead in cases where the desired link type is not applicable. For example, a shortcut will be created if the drives are not NTFS or for files where the source and destination are on different drives.</p><p><em>Example:</em> <code>Copy MAKELINK=autonosoft</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| MAKESFX           | /O   | _(no value)_              | <p>Creates a <a href="../../../file_operations/creating_archives/zip_files/self-extracting_zip_files">self-extracting Zip file</a> from selected files and folders. If you select a .zip file then it will be converted directly to self-extracting format; otherwise, the selected items will be zipped first.</p><p><em>Example:</em> <code>Copy MAKESFX</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| MARKDESTARCHIVE   | /K   | **yes**                   | <p>Clears the <strong>A</strong> ("ready for archiving") attribute on newly copied files. You can use this if your backup solution uses the <strong>A</strong> attribute to indicate a file has changes which need backing up, and you don't want the new copy to be backed up (until something modifies it and sets its <strong>A</strong> attribute again).</p><p>Overrides the **Mark copied files as archived (clear the A flag) **option on the <a href="../../../preferences/preferences_categories/file_operations/copying_files/attributes"><strong>Copying Files / Attributes</strong></a> Preferences page.</p><p>This does nothing if not preserving file attributes on copied files.</p><p><em>Example:</em> <code>Copy MARKDESTARCHIVE=yes</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|                   |      | **no**                    | <p>Do not clear the <strong>A</strong> attribute on newly copied files.</p><p><em>Example:</em> <code>Copy MARKDESTARCHIVE=no</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| MARKSOURCEARCHIVE | /K   | **yes**                   | <p>Clear the <strong>A</strong> ("ready for archiving") attribute on the original files after they have been copied. You can use this if your backup solution uses the <strong>A</strong> attribute to indicate a file has changes which need backing up, and you don't want the original files to be backed up.</p><p>Overrides the <strong>Mark original files as archived after being copied (clear the A flag)</strong> option on the <a href="../../../preferences/preferences_categories/file_operations/copying_files/attributes"><strong>Copying Files / Attributes</strong></a> Preferences page.</p><p><em>Example:</em> <code>Copy MARKSOURCEARCHIVE=yes</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|                   |      | **no**                    | <p>Do not clear the <strong>A</strong> attribute on the original files after they are copied.</p><p><em>Example:</em> <code>Copy MARKSOURCEARCHIVE=no</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| MOVE              | /S   | _(no value)_              | <p>Move selected files and folders to the destination (a.k.a. cut-and-paste). If the destination folder is on the same drive as the source then generally items can be moved through a simple rename operation, which is very quick. When moving files between devices Opus first copies them to the destination, and then deletes them from the source.</p><p><em>Example:</em> <code>Copy MOVE</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| MOVEWHENSAME      | /S   | _(no value)_              | <p>If the destination folder is on the same drive as the source then selected items will be moved, otherwise they will be copied. This command is used in the default <a href="../../../file_types/filetype_editor/events">drag-and-drop file type event</a> (which mimics the standard Explorer drag-and-drop behaviour where files are moved if you drag them to a different folder on the same drive, and copied otherwise).</p><p><em>Example:</em> <code>Copy MOVEWHENSAME</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| MOVEWITHSHIFT     | /S   | _(no value)_              | <p>Selected items will be moved if the <strong>Shift</strong> key is held down when the command is executed, otherwise they will be copied.</p><p><em>Example:</em> <code>Copy MOVEWITHSHIFT</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| NONBUFIO          | /K   | **yes**                   | <p>Changes when the copy operation uses non-buffered mode, where the filesystem buffers provided by Windows are bypassed.</p><p>For very large files, copying in non-buffered mode can increase the memory efficiency, copy speed and UI responsiveness. On the other hand, non-buffered mode may slow things down for smaller files or certain devices. In rare cases, non-buffered mode may not work at all (e.g. if you have a device which mis-reports its sector size).</p><p>Use of this argument overrides the default file size threshold for non-buffered copies set via the <strong>copy_nonbufferio_threshold</strong> <a href="../../../preferences/preferences_categories/miscellaneous/advanced_options">Advanced</a> Preferences setting.</p><p>You can specify "yes" or "no" to force non-buffered mode on or off for all files, or specify the file size above which non-buffered mode should be used.</p><p><em>Example:</em> <code>Copy NONBUFIO=yes</code></p><p>This has no effect when doing simple file-to-file copies and delegating to the very-high-level Windows file-copy API, since that API performs its own buffering. See the <strong>DELEGATE</strong> argument for more detail.</p>                                                                                                                                              |
|                   |      | **no**                    | <p>Forces the copy operation to be buffered, even if the file being copied exceeds the threshold size set via the <strong>copy_nonbuffer_threshold</strong> <a href="../../../preferences/preferences_categories/miscellaneous/advanced_options">Advanced</a> Preferences setting.</p><p><em>Example:</em> <code>Copy NONBUFIO=no</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|                   |      | _\<threshold size>_       | <p>The copy operation will be non-buffered if the file size exceeds the specified size, and buffered otherwise. When specifying a size, units can be KB, MB or GB. If no units are specified, MB is used by default.</p><p><em>Example:</em> <code>Copy NONBUFIO=64MB</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| NOQUEUEWHENSAME   | /S   | _(no value)_              | <p>Disables the use of the copy queue when the source and destination paths are on the same drive partition. You would normally only use this argument when moving files, because moves on the same drive can be done without actually copying any data.</p><p><em>Example:</em> <code>Copy MOVE NOQUEUEWHENSAME</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| PATTERN           | /K   | _\<old name pattern>_     | <p>Specifies the "old name" or "from" <a href="../../../file_operations/copying_moving_and_deleting_files/copying_using_the_toolbar_buttons/using_wildcards_when_copying">wildcard pattern</a> for the copied or moved files. Use this in conjunction with <strong>AS</strong> to control wildcard renaming of copied or moved files.</p><p><em>Example:</em> <code>Copy DUPLICATE PATTERN *.* AS *_{date|yyyy-MM-dd}.</code>*</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| QUEUE             | /O   | _(no value)_              | <p>Enables automatic <a href="../../../file_operations/copying_moving_and_deleting_files/copy_queues">copy queuing</a>. File copies will be queued automatically if required (based on the source and destination drives). This can override the <strong>Automatically manage file copy queues</strong> option on the <a href="../../../preferences/preferences_categories/file_operations/copying_files"><strong>Copying Files</strong></a> Preferences page.</p><p><em>Example:</em> <code>Copy QUEUE</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|                   |      | _\<queue name>_           | <p>When you specify a queue name as the value for this argument, it enables manual copy queuing when copying files. That is, with a name specified, file copies will always be queued to the specified queue - if no name is specified for the argument, copies will only be queued if needed. The specified name will be shown in the progress dialog's title bar.</p><p><em>Example:</em> <code>Copy QUEUE=MyQueue</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|                   |      | **none**                  | <p>Used to disable copy queuing - whether enabled in Preferences, or otherwise enabled by the <strong>shift</strong> keyword.</p><p><em>Example:</em> <code>Copy QUEUE=none</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                   |      | **shift**                 | <p>Lets you specify two alternate parameters for the <strong>QUEUE</strong> argument. The value specified before the <strong>shift</strong> keyword is used if the <strong>Shift</strong> key is not held down - the value after it is used if it is. For example, you could configure a copy button to queue files to a specific queue if the <strong>Shift</strong> key were held down, and to disable queuing otherwise.</p><p><em>Example:</em> <code>Copy QUEUE=none,shift,MyQueue TO \\NAS1\Storage</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|                   |      | **quiet**                 | <p>Specify the <strong>quiet</strong> keyword to suppress the prompt that normally indicates a copy operation has been queued. (Opus 13.9.1 and above: You can also turn off <em>Display confirmation when a job is queued</em> in Preferences.)</p><p><em>Example:</em> <code>Copy QUEUE=MyQueue,quiet</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|                   |      | **noisy**                 | <p>(Opus 13.9.1 and above.) Specify the <strong>noisy</strong> keyword to always show a prompt indicating a copy operation has been queued, even if <em>Display confirmation when a job is queued</em> is off in Preferences.</p><p><em>Example:</em> <code>Copy QUEUE=MyQueue,noisy</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| RENAMEWHENSAME    | /S   | _(no value)_              | <p>If the source and destination are the same folder, the newly copied file will be automatically renamed to avoid a clash.</p><p><em>Example:</em> <code>Copy RENAMEWHENSAME</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| SENDMAIL          | /O   | _(no value)_              | <p>Send selected files as email attachments. Email settings must be configured on the <a href="../../../preferences/preferences_categories/internet/email"><strong>Internet / Email</strong></a> Preferences page.</p><p><em>Example:</em> <code>Copy SENDMAIL</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
|                   |      | _\<email address>_        | <p>Send selected files to the specified email recipient. This only works if email sending is set to use the <strong>MAPI client</strong> on the <a href="../../../preferences/preferences_categories/internet/email"><strong>Internet / Email</strong></a> Preferences page.</p><p><em>Example:</em> <code>Copy SENDMAIL=f.bloggs@company.com</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| SENDTO            | /K   | _\<send-to target>_       | <p>Send selected files to the specified "send to" target. This can be any item that appears in the system <em>Send To</em> context menu, and lets you perform the same action without actually displaying the context menu. The value given for the target must be the name of the actual file in the <em>SendTo</em> folder (to find the <em>SendTo</em> folder and see what's in there, use the <strong>/sendto</strong> <a href="../../../basic_concepts/the_lister/navigation/aliases">folder alias</a>).</p><p><em>Example:</em> <code>Copy SENDTO "Web Publishing Wizard"</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| SYNC              | /S   | _(no value)_              | <p>Performs the copy stage of a <a href="../../../file_operations/copying_moving_and_deleting_files/copying_updated_files/synchronize">synchronize</a> operation. You must first have used the <a href="find"><strong>Find</strong></a> <strong>SYNC</strong> command to perform the comparison stage.</p><p>//<a href="example://">Example://</a> See the <code>Find SYNC</code> <a href="../find#SYNC">command</a> for an example</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| TO                | /K   | _\<target path>_          | <p>Specify the target path for the command. By default Copy functions that require a destination folder will use the current destination file display or Lister - this argument allows you to override that. Also see the HERE argument for a way to override the destination path. You can use <a href="../../../basic_concepts/the_lister/navigation/aliases">folder aliases</a>and <a href="../../../ftp/ftp_paths">@ftp shortcuts</a>, URL-style paths for <a href="../../../basic_concepts/virtual_file_system">virtual filesystems</a> (<a href="../../../basic_concepts/virtual_file_system/file_collections">collections</a>, <a href="../../../basic_concepts/virtual_file_system/libraries">libraries</a>, etc.) as well as standard file system paths. Remember that if the specified path contains a space you must enclose the whole path in quotes. This only sets the destination folder; if you want to change the names of the copied files as well, use the <strong>AS</strong> argument.</p><p>Note that specifying the target path in this way disables automatic <a href="../../../file_operations/copying_moving_and_deleting_files/copy_queues">copy queues</a>. You can use the <strong>QUEUE</strong> argument to place these operations in a queue.</p><p><em>Example:</em> <code>Copy TO "lib://Backups/Daily Backup Folder"</code></p> |
|                   |      | **ask**                   | <p>Normally if no destination path is specified, and there is no current destination file display or Lister, Opus will prompt for a destination path via a popup dialog. You can use the <strong>ask</strong> value to force Opus to always prompt for a destination path, even if there already is one.</p><p>You can also specify a default destination path, by appending a colon and the path. Remember to use quotes if the path contains spaces.</p><p><em>Example:</em> <code>Copy TO=ask</code><br><em>Example:</em> <code>Copy TO="ask:c:\My Documents"</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|                   |      | **ask$**                  | <p>Force Opus to ask for a destination path. If you have a function that combines multiple <strong>Copy</strong> commands, you can use <strong>ask$</strong> to make Opus only prompt for a destination path once for the whole function, rather than prompting separately for each <strong>Copy</strong> command.</p><p>You can also specify a default destination path, by appending a colon and the path.</p><p><em>Example:</em> <code>Copy TO=ask\$</code><br>``Copy TO=ask$:D:\`</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| UNATTENDED        | /K   | **yes**                   | <p>Enables <a href="../../../file_operations/copying_moving_and_deleting_files/copy_queues/unattended_operation">unattended copy</a> mode. In this mode, Opus will not display any confirmation prompts or error dialogs - the copy will proceed until the end, and any errors will be summarised upon completion. Use the other arguments like <strong>WHENEXISTS</strong> to control what happens in certain situations.</p><p><em>Example:</em> <code>Copy UNATTENDED=yes TO=@myftpsite WHENEXISTS=replace</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|                   |      | **no**                    | <p>Disables unattended copy mode.</p><p><em>Example:</em> <code>Copy UNATTENDED=no</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| UPDATEALL         | /S   | _(no value)_              | <p>Update files in the destination folder (<a href="../../../file_operations/copying_moving_and_deleting_files/copying_updated_files">a simple form of one-way synchronization</a>). Only files that either do not exist in the destination, or do exist but are different from the source files, will be copied - other files will be skipped.</p><p>(Compare this with <strong>UPDATEEXISTING</strong> which only updates files that already exist.)</p><p>A file is defined as different if either its timestamp is newer or its size has changed - the contents of the file are not compared.</p><p><em>Example:</em> <code>Copy UPDATEALL FORCE</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|                   |      | **date**                  | <p>Update existing files whose timestamp is different (ignore file size).</p><p><em>Example:</em> <code>Copy UPDATEALL=date</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                   |      | **size**                  | <p>Update existing files whose size is different (ignore timestamp).</p><p><em>Example:</em> <code>Copy UPDATEALL=size</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|                   |      | **smaller**               | <p>When used with <strong>size</strong>, only updates files whose size is smaller (rather than just different).</p><p><em>Example:</em> <code>Copy UPDATEALL=size,smaller</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|                   |      | **larger**                | <p>When used with <strong>size</strong>, only updates files whose size is larger..</p><p><em>Example:</em> <code>Copy UPDATEALL=size,larger</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| UPDATEEXISTING    | /O   | _(no value)_              | <p>Update existing files in the destination folder (<a href="../../../file_operations/copying_moving_and_deleting_files/copying_updated_files">a simple form of one-way synchronization</a>). Only files that already exist in the destination, but are different from the source files, will be copied. Files that do not already exist, as well as files that have not changed, will be skipped.</p><p>(Compare this with <strong>UPDATEALL</strong> which also copies files that don't already exist.)</p><p>A file is defined as different if either its timestamp is newer or its size has changed.</p><p><em>Example:</em> <code>Copy UPDATEEXISTING</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|                   |      | **date**                  | <p>Update existing files whose timestamp is different (ignore file size).</p><p><em>Example:</em> <code>Copy UPDATEEXISTING=date</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|                   |      | **size**                  | <p>Update existing files whose size is different (ignore timestamp).</p><p><em>Example:</em> <code>Copy UPDATEEXISTING=size</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                   |      | **smaller**               | <p>When used with <strong>size</strong>, only updates files whose size is smaller (rather than just different).</p><p><em>Example:</em> <code>Copy UPDATEEXISTING=size,smaller</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
|                   |      | **larger**                | <p>When used with <strong>size</strong>, only updates files whose size is larger..</p><p><em>Example:</em> <code>Copy UPDATEEXISTING=size,larger</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| UPDATESECURITY    | /K   | **yes**                   | <p>Update security permissions and encryption settings for moved* files to match their destination folders.</p><p>Overrides the <strong>Update permissions/encryption to match the destination when moving files</strong> option on the <a href="../../../preferences/preferences_categories/file_operations/copying_files/attributes"><strong>Copying Files / Attributes</strong></a> Preferences page.</p><p>For example, if a folder has the <strong>E</strong> attribute set, files moved into that folder will be automatically encrypted.</p><p>This only applies to files moved between folders on the same logical drive. For files that are moved between drives, the operation is done via a copy-then-delete and the newly copied files will usually inherit the permissions of the destination folder by default (unless overridden by the separate <strong>COPYSECURITY</strong> argument or related Preferences setting).</p><p><em>Example:</em> <code>Copy UPDATESECURITY=yes</code></p>                                                                                                                                                                                                                                                                                                                                                           |
|                   |      | **no**                    | <p>Do not update security permissions or encryption settings for files moved between folders on the same logical drive. Such files will instead retain the permissions they had in their original folders.</p><p><em>Example:</em> <code>Copy UPDATESECURITY=no</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| UPDATETOLERANCE   | /K/N | _\<tolerance seconds>_    | <p>Sets the maximum number of seconds an existing file's timestamp can vary before it will be considered "different" by the <strong>UPDATEALL</strong> or <strong>UPDATEEXISTING</strong> functions. The default is two seconds (that is, a file will be considered different if its timestamp is two or more seconds different to the source file). You can use this to make allowances for daylight-savings time, or for file systems that don't preserve file dates to a high enough resolution.</p><p><em>Example:</em> <code>Copy UPDATEEXISTING UPDATETOLERANCE=3600</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| WHENEXISTS        | /K   | **ask**                   | <p>If a file that is being copied already exists in the destination, ask what to do. This overrides the option <strong>Ask for confirmation before overwriting existing files</strong> on the <a href="../../../preferences/preferences_categories/file_operations/copying_files/confirmation"><strong>Copying Files / Confirmation</strong></a> page in Preferences.</p><p><em>Example:</em> <code>Copy WHENEXISTS=ask</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|                   |      | **skip**                  | <p>If a file that is being copied already exists in the destination, skip over it (leaving existing file intact).</p><p><em>Example:</em> <code>Copy WHENEXISTS=skip</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|                   |      | **recycle**               | <p>When replacing a file, delete the original to the recycle bin if possible. You can combine this flag with the other options.</p><p>Note that <strong>Undo</strong> can not be used to restore these files automatically, however you will be able to retrieve them from the recycle bin manually.</p><p><em>Example:</em> <code>Copy WHENEXISTS=replace,recycle</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                   |      | **replace**               | <p>Replace any existing files without prompting.</p><p><em>Example:</em> <code>Copy WHENEXISTS=replace</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|                   |      | **rename**                | <p>If a file with the same name already exists in the destination, the newly copied file will be renamed automatically to avoid a clash.</p><p><em>Example:</em> <code>Copy WHENEXISTS=rename</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|                   |      | **renameold**             | <p>The old file (the one that already exists in the destination directory) will be renamed before the new file is copied.</p><p><em>Example:</em> <code>Copy WHENEXISTS=renameold</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|                   |      | **resume**                | <p>When copying to FTP sites, a previous incomplete file transfer will be automatically resumed (only applies if the server supports FTP, and the existing file is smaller than the one being copied).</p><p><em>Example:</em> <code>Copy WHENEXISTS=resume</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                   |      | **merge**                 | <p>Automatically merge the contents of an existing folder with that of the folder being copied. This overrides the <strong>Ask for confirmation before merging existing folders</strong> option on the <a href="../../../preferences/preferences_categories/file_operations/copying_files/confirmation"><strong>Copying Files / Confirmation</strong></a> page in Preferences. You can use this value in addition to another value to specify the 'when exists' behaviour for files as well as folders.</p><p><em>Example:</em> <code>Copy WHENEXISTS=replace,merge</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|                   |      | **keepnewer**             | <p>Replace any existing files if the files being copied are newer. If the timestamps are the same or older, the already-existing files will be skipped.</p><p><em>Example:</em> <code>Copy WHENEXISTS=keepnewer</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
