<type>documentation</type>
<domain>intro</domain>
<id>tutorial-other</id>
<title>Tutorial: Other IDE Features</title>
<date>$Date: 2004-09-27 15:29:57 -0400 (Mon, 27 Sep 2004) $</date>
<product>per+</product>

By now you have seen many of the IDE's features.  Before we call it a day,
let's look at a few other major features that are worth knowing about.

~~~if WINGPRO:
**Remote Development**

Wing Pro makes it possible to work with Python source code that resides on a remote host,
container, or virtual machine. This is done by setting up SSH access to the remote host,
then configuring Wing using ``Remote Hosts`` in the ``Project`` menu, and pointing
``Python Executable`` in ``Project Properties`` at that remote host.

Once this is done, remote files and directories can be added to the project with ``Add
Existing Directory`` in the ``Project`` menu. Then Wing will be able to edit, debug, test,
search, inspect, refactor, and manage remote files, and it can run ``Python Shell`` and
``OS Commands`` on the remote host.

See `Remote Hosts <ref:proj/remote-hosts>`__ for details.
~~~

~~~if WINGPER:
**PyLint Integration**

Wing Personal's ``PyLint`` tool, available in the ``Tools`` menu, provides a simple
integration with the Python code inspection tool ``Pylint``. This tool is replaced in Wing
Pro by the ``Code Warnings`` tool, which can manage code warnings from a variety of
sources, including Pylint.

To use Pylint with Wing Personal, you first need to install ``pylint`` separately. Then
right-click on the ``Pylint`` tool in Wing to configure the integration.

Use the ``Update`` items in the right-click context menu on the ``PyLint`` tool to update
the tool's contents for the current file or package. Clicking on errors, warnings, and
informational messages takes you to the source code that ``pylint`` is flagging.

.. image:: pylint.png
  :width: 617
  :height: 171
  
See the `PyLint <ref:edit/pylint>`__ documentation page for more information on the
PyLint integration.
~~~

**OS Commands**

The `OS Commands <script:show-panel-os-command>`__ tool can be used to set up, execute,
and interact with external commands, for building, deployment, and other tasks.  The
``Build Command`` field in the ``Debug/Execute`` tab of ``Project Properties`` can be used
to configure and select one command to execute automatically before any debug session
begins.  OS Commands can also be bound to keys, and the ``Start Terminal`` item in the
``Tools`` menu uses it to start command prompt in Wing:

.. image:: oscommands.png
  :width: 762
  :height: 211

See `OS Commands Tool <ref:oscommands/index>`__ for details.

**Source Browser**

The `Source Browser <script:show-panel-browser>`__ in Wing Pro and Wing Personal can be
used to inspect and navigate the module and class structure of your Python source code.

.. image:: source-browser.png
  :width: 315
  :height: 350

Double-clicking on items in the ``Source Browser`` opens them into an editor. When
``Follow Selection`` is enabled in the ``Options`` menu, Wing also opens files that are
single-clicked or visited by keyboard navigation within the ``Source Browser``.

The popup menu at the top left of the ``Source Browser`` selects whether to browse the
current file, all project modules, or all project classes. The ``Options`` menu in the top
right allows sorting and filtering symbols by type.

Notice that the `Source Assistant`__ tool is integrated with the ``Source Browser``, and
will update its content as you move around the ``Source Browser``.

__ script:show_panel#panel_type="source-assistant"

**File Sets**

Wing allows you to create named sets of files which you can open as a group or search in
the `Search in Files <script:show-panel-batch-search>`__ tool. See `File Sets
<ref:edit/file-sets>`__ for details.

**File Operations**

Files can be created, deleted, moved, and renamed from the ``Project`` tool by
right-clicking, dragging, and clicking on names in the tree. Deleted files are moved to
the system's trash or recycling bin.

When files are in a revision control system, Wing will also issue the necessary revision
control commands to create, delete, move, or rename the file in the repository.

See `File Operations <ref:proj/file-operations>`__ for details.

**Perspectives**

Perspectives are a way to store and later revisit particular arrangements of the user
interface. For example, you may set up one set of visible tools to use when testing,
another for working on documentation, and still another for debugging.

Perspectives are accessed from the ``Tools`` menu.  

.. image:: perspectives.png
  :width: 433
  :height: 233

Wing can optionally switch perspectives automatically whenever debugging starts or stops,
so that the user interface differs according to how the tools were left when last editing
or debugging. This is done by selecting ``Enable Auto-Perspectives`` in the ``Tools``
menu.

See `Perspectives <ref:custom/perspectives>`__  for details.

**Extending the IDE**

Wing can be extended by writing Python scripts that call into the IDE's scripting API.
This is useful for adding everything from simple editor commands and debugger add-ons to
new tools.

There is a collection of user-contributed scripts for Wing in the `contributed materials
<http://bitbucket.org/sdeibel/wing-contrib>`__ area.

See also `Scripting and Extending Wing <ref:scripting/index>`__.

