Software Installation for EiffelStudio

Select the operating system you are using for detailed installation instructions:

Mac OS X

Note: The Mac OS X version is currently only available under the GPL license and can be downloaded by following the instructions at http://dev.eiffel.com/EiffelOnMac. The instructions below are not currently applicable for Mac OS X.

Contents 1 Requirements 2 Prerequisites 3 Installing the Free Edition 4 Installing the Enterprise Edition 5 Starting EiffelStudio

Requirements

Computer/Processor	x86-64
Operating System	Mac OS X 10.8 or above
C compiler	gcc included in XCode
Memory	512MB of RAM (1GB recommended)
Hard Disk	400MB of hard disk space (1GB recommended)
Drive	CD-ROM or DVD drive (not required when downloading EiffelStudio)
Display	1024 x 768 or higher resolution video adapter and monitor
Peripherals	Keyboard and mouse or compatible pointing device
ISE_PLATFORM	macosx-x86' for x86 based CPU and macosx-x86-64 for x64 based CPU.

Prerequisites

• You will need to install Xcode from the App Store. (On old versions of OS X, Xcode was on your OSX-Installation disk, or you downloaded it from Apple's developer web site.) After installing Xcode, make sure to install the command line tools by going to the Xcode preferences and under Downloads install the Command Line Tools components.

• You also need to install X11:
  • On OS X 10.8 (Mountain Lion): install it from http://xquartz.macosforge.org.
  • On OS X 10.5, 10.6 and 10.7: nothing to be done.
  • ON OS X 10.4 and older: install it from your OS X installation disk.

Installing the Free Edition

After downloading the EiffelXX.dmg installation package (where XX stands for the EiffelStudio version), double click on it to mount the disk image. Then double click on the EiffelXX.pkg file to launch the installation procedure. Follow the steps indicated in the dialogs to complete the installation.

Installing the Enterprise Edition

Insert the CD into your CD-ROM drive. Open the CD-ROM contents and double click on the EiffelXX.pkg file to launch the installation procedure. Follow the steps indicated in the dialogs to complete the installation.

Run EiffelStudio, located at /Developers/Applications/EiffelXX/EiffelStudio. Enter the information located inside the box that contains your copy of the EiffelStudio Enterprise Edition. Once the information is correct, the Register button will be enabled. Click Register to actually register EiffelStudio.

You now need to launch EiffelStudio to register your copy. Follow the instructions located in the Starting EiffelStudio section below. The first time you launch EiffelStudio, you will be asked for an activation key through the following dialog:

By clicking on the http://activate.eiffel.com URL, a new web browser will appear with the requested fields automatically filled in with the appropriate information. Simply click Activate and a new page with an activation code will appear. Copy and paste the activation code in the first field and the Activate button should be enabled to let you activate your copy.

You can activate your copy up to three times. Once you have reached this threshold and need to reinstall your copy, contact Eiffel Software to request one more activation.

If no web broswer appears, it is most likely because Safari is not installed on your machine or is not in your path. Instead you should manually launch a new web browser and go to the page http://activate.eiffel.com and enter the information manually. Then follow the above instructions as if the browser had been properly launched.

You may receive the following dialog when launching EiffelStudio:

This probably means that the register program was not launched or did not succeed in storing data to the following file /Developer/Applications/EiffelXX/EiffelStudio.app/Contents/Resources/EiffelXX/install/limand/.ec_license. To solve this, rerun the register program with a user account that has permissions to write at /Developer/Applications/EiffelXX/EiffelStudio.app/Contents/Resources/EiffelXX/install/limand and enter your Username and CD Key.

Starting EiffelStudio

Now everything should be properly installed and you should be able to run the compiler. You can now launch EiffelStudio from the Finder under /Developer/Applications/EiffelXX/. If you are a new user to EiffelStudio, we recommend that you follow the guided tour .

FreeBSD

Contents 1 Requirements 2 Checking your environment 3 Installing EiffelStudio from the Web 4 Installing EiffelStudio from a CD-ROM 5 Setting up EiffelStudio 6 Registering the Enterprise Edition 7 Using EiffelStudio 7.1 Starting EiffelStudio 7.2 EiffelStudio Appearance

Requirements

Computer/Processor	PC with 300 MHz or higher Pentium II class processor or equivalent recommended.
Operating System	FreeBSD 5.2 with either Gnome 2.6 or GTK+ 2.4.
C compiler	gcc
Memory	512 MB of RAM (1GB recommended).
Hard Disk	400Mb uncompressed hard disk space (700Mb recommended).
Drive	CD-ROM or DVD drive (not required when downloading EiffelStudio).
Display	1024 x 768 or higher resolution video adapter and monitor.
Peripherals	Keyboard and mouse or compatible pointing device.
ISE_PLATFORM	freebsd-x86 for x86 based CPU and freebsd-x86-64 for x64 based CPU.

Checking your environment

EiffelStudio requires GTK+ 2.4.0 or above to function properly. You can check that you have this installed correctly by typing the following command: pkg-config --modversion gtk+-2.0 The command should succeed and the version number of GTK+ should appear. If it is not 2.4.0 or above then you cannot continue the installation of EiffelStudio. You first need to install GTK+ 2.4.0.

Installing EiffelStudio from the Web

After downloading the installation package, you should manually extract its contents to your hard drive. For example, you can extract it into /usr/local using the following commands (assuming that you have permission to /usr/local and that the installation package was saved in /tmp/EiffelXX.tar.bz2, where XX corresponds to the EiffelStudio version number):

cd /usr/local
tar xvfj /tmp/EiffelXX.tar.bz2

This will install EiffelStudio files into /usr/local/EiffelXX. Once this is done, jump to the Setting up EiffelStudio section in order to complete the installation of EiffelStudio.

Installing EiffelStudio from a CD-ROM

Insert the CD into your CD-ROM drive. You should manually extract its contents to your hard drive. For example you can extract it in /usr/local using the following commands (assuming that you have permission to /usr/local and that the CD is mounted on /mnt/cdrom):

cd /usr/local
cp -r /mnt/cdrom/EiffelXX .

This will install the EiffelStudio files into /usr/local/EiffelXX. To complete the installation of EiffelStudio, jump to the next section, Setting up EiffelStudio.

Setting up EiffelStudio

Once the files have been installed, you should define the following environment variables in order to run EiffelStudio:

• ISE_EIFFEL to /usr/local/EiffelXX
• ISE_PLATFORM to freebsd-x86.

and add $ISE_EIFFEL/studio/spec/$ISE_PLATFORM/bin to your PATH environment variable.

Using sh or bash as a shell, it suffices to type the following commands:

export ISE_EIFFEL=/usr/local/EiffelXX
export ISE_PLATFORM=freebsd-x86
export PATH=$PATH:$ISE_EIFFEL/studio/spec/$ISE_PLATFORM/bin

Using csh or tcsh as a shell, it suffices to type the following commands:

setenv ISE_EIFFEL /usr/local/EiffelXX
setenv ISE_PLATFORM freebsd-x86
set path = ($path $ISE_EIFFEL/studio/spec/$ISE_PLATFORM/bin)

If you are using the Enterprise edition, please follow the instructions of the next section, Registering the Enterprise Edition, otherwise jump to the Using EiffelStudio section at the end of this document.

Registering the Enterprise Edition

This step assumes you have followed the instructions in the Setting up EiffelStudio section. Perform the following commands to start the registration process:

cd $ISE_EIFFEL
./register

A dialog asking for your Username and CD Key should appear as it does below:

Enter the information located inside the box that contains your copy of the EiffelStudio Enterprise Edition. Once the information is correct, the Register button will be enabled. Click Register to actually register EiffelStudio.

The first time you launch EiffelStudio, you will be asked for an activation key through the following dialog:

By clicking on the http://activate.eiffel.com URL, a new web browser will appear with the requested fields automatically filled in with the appropriate information. Simply click Activate and a new page with an activation code will appear. Copy and paste the activation code in the first field and the Activate button should be enabled to let you activate your copy.

You can activate your copy up to three times. Once you have reached this threshold and need to reinstall your copy, contact Eiffel Software to request one more activation.

If no web browser appears, it is most likely because firefox is not installed on your machine or is not in your path. Instead you should manually launch a new web browser, go to the page http://activate.eiffel.com , and enter the information manually. Then follow the above instructions as if the browser had been properly launched.

You may receive the following dialog when launching EiffelStudio:

This probably means that the register program was not launched or did not succeed in storing data to the following file $ISE_EIFFEL/install/limand/.ec_license. To solve this, rerun the register program with a user account that has permissions to write at $ISE_EIFFEL/install/limand and enter your Username and CD Key.

Once this is done, you can jump to the next section, Using EiffelStudio.

Using EiffelStudio

Starting EiffelStudio

Now everything should be properly installed and you should be able to run the compiler. Launch estudio for the interactive graphical user interface of the compiler, or launch ec for the command line interface. If you are a new user to EiffelStudio, we recommend that you follow the guided tour.

EiffelStudio Appearance

EiffelStudio for Unix uses the GTK+ theme engine to allow for custom appearance such as changing the default font size and color of windows, etc. If you do not have a theme manager (such as that provided with Gnome) you can copy the .gtkrc-2.0 file from $ISE_EIFFEL/eifinit/studio/spec/gtk directory to your $HOME directory.

HP OpenVMS

Contents 1 Requirements 2 Checking your environment 3 Installing the Enterprise Edition 3.1 From the Web 3.2 From a CD 3.3 Completing the installation

Requirements

Computer/Processor	AlphaServer.
Operating System	HP OpenVMS/Alpha version 7.3.2 with DECWindows and GTK+ 1.2.10.
C compiler	Compaq C compiler V6 or later.
Memory	512MB of RAM (1GB recommended).
Hard Disk	1GB free disk space on an ODS-5 formatted volume, plus an additional 1GB of free space while performing the software installation.
Drive	CD-ROM or DVD drive (not required when downloading EiffelStudio).
Display	1024 x 768 or higher resolution video adapter and monitor.
Peripherals	Keyboard and mouse or compatible pointing device.

Checking your environment

EiffelStudio requires GTK+ 1.2.10 or above to function properly. You can check that you have this installed correctly by typing the following command: gtk-config --version The command should succeed and the version number of GTK+ should appear. If it is not 1.2.10 or above then you cannot continue the installation of EiffelStudio. You first need to install GTK+ 1.2.10.

Installing the Enterprise Edition

From the Web

After downloading the eifXXvms.zip installation package (where XX stands for the EiffelStudio version number), unzip the distribution into temp:[dir] where where temp:[dir] is the location of a temporary directory: unzip eifXXvms.zip temp:[dir]

And use the following commands to install the files into eiffel_installation_path where eiffel_installation_path is a device:[directory] on an ODS-5 volume:

set file/attrib=(org:seq,rfm:fix,lrl:9216) temp:[dir]eifXXvms.save
backup temp:[dir]eifXXvms.save/save eiffel_installation_path

From a CD

You must mount the installation CD-ROM volume with the following qualifier: mount cd_dev:/media_format=cdrom/undefined_fat=fixed:cr:9216

where cd_dev: is the CD-ROM device. And use the following commands to install the files into eiffel_installation_path where eiffel_installation_path is a device:[directory] on an ODS-5 volume: backup cd_dev:[000000]eifXXvms.save/save eiffel_installation_path

Completing the installation

You must define a system-wide rooted logical name to reference the installation directory, for instance: define/system EIFFELXX eiffel_installation_path:[directory.] /trans=conceal

To use EiffelStudio for OpenVMS, run the setup procedure to define the environment: @eiffel_installation_path:[000000]setup This will define the logical names and DCL symbols required to run Eiffel.

Once the files are copied and once the environment is setup up set, you need to register EiffelStudio. To do so type the following command: RUN ISE_EIFFEL:[000000]register

A dialog asking for your Username and CD Key should appear as it does below:

Enter the information located inside the box that contains your copy of the EiffelStudio Enterprise Edition. Once the information is correct, the Register button will be enabled. Click Register to actually register EiffelStudio.

The first time you launch EiffelStudio, you will be asked for an activation key through the following dialog:

By clicking on the http://activate.eiffel.com URL, a new web browser will appear with the requested fields automatically filled in with the appropriate information. Simply click Activate and a new page with an activation code will appear. Copy and paste the activation code in the first field and the Activate button should be enabled to let you activate your copy.

You can activate your copy up to three times. Once you have reached this threshold and need to reinstall your copy, contact Eiffel Software to request one more activation.

If no web broswer appears, it is most likely because netscape is not installed on your machine or is not in your path. Instead you should manually launch a new web browser and go to the page http://activate.eiffel.com and enter the information manually. Then follow the above instructions as if the browser had been properly launched.

You may receive the following dialog when launching EiffelStudio:

This probably means that the register program was not launched or did not succeed in storing data to the following file ISE_EIFFEL:[install.limand].ec_license. To solve this, rerun the register program with a user account that has permissions to write at ISE_EIFFEL:[install.limand] and enter your Username and CD Key.

Once this is done you can jump to the next section "Using EiffelStudio."

HP-UX

Contents 1 Requirements 2 Checking your environment 3 Installing EiffelStudio from the Web 4 Installing EiffelStudio from a CD-ROM 5 Setting up EiffelStudio 6 Registering the Enterprise Edition 7 Using EiffelStudio 7.1 Starting EiffelStudio 7.2 EiffelStudio Appearance

Requirements

Computer/Processor	HP-PA.
Operating System	HP-UX 11 with GTK+ 2.4.
C compiler	HP C compiler
Memory	512MB of RAM (1GB recommended).
Hard Disk	500MB of hard disk space (1GB recommended).
Drive	CD-ROM or DVD drive (not required when downloading EiffelStudio).
Display	1024 x 768 or higher resolution video adapter and monitor.
Peripherals	Keyboard and mouse or compatible pointing device.
ISE_PLATFORM	hpux-11.

Checking your environment

EiffelStudio requires GTK+ 2.4.0 or above to function properly. You can check that you have this installed correctly by typing the following command: pkg-config --modversion gtk+-2.0 The command should succeed and the version number of GTK+ should appear. If it is not 2.4.0 or above then you cannot continue the installation of EiffelStudio. You first need to install GTK+ 2.4.0.

Installing EiffelStudio from the Web

After downloading the installation package, you should manually extract its contents to your hard drive. For example, you can extract it into /usr/local using the following commands (assuming that you have permission to /usr/local and that the installation package was saved in /tmp/EiffelXX.tar.bz2, where XX stands for the EiffelStudio version number):

cd /usr/local
tar xvfj /tmp/EiffelXX.tar.bz2

This will install EiffelStudio files into /usr/local/EiffelXX. Once this is done, jump to the Setting up EiffelStudio section in order to complete the installation of EiffelStudio.

Installing EiffelStudio from a CD-ROM

Insert the CD into your CD-ROM drive. You should manually extract its contents to your hard drive. For example you can extract it in /usr/local using the following commands (assuming that you have permission to /usr/local and that the CD is mounted on /mnt/cdrom):

cd /usr/local
cp -r /mnt/cdrom/EiffelXX .

This will install the EiffelStudio files into /usr/local/EiffelXX. To complete the installation of EiffelStudio, jump to the next section, Setting up EiffelStudio.

Setting up EiffelStudio

Once the files have been installed, you should define the following environment variables in order to run EiffelStudio:

• ISE_EIFFEL to /usr/local/EiffelXX
• ISE_PLATFORM to hpux-11.

and add $ISE_EIFFEL/studio/spec/$ISE_PLATFORM/bin to your PATH environment variable.

Using sh or bash as a shell, it suffices to type the following commands:

export ISE_EIFFEL=/usr/local/EiffelXX
export ISE_PLATFORM=hpux-11
export PATH=$PATH:$ISE_EIFFEL/studio/spec/$ISE_PLATFORM/bin

Using csh or tcsh as a shell, it suffices to type the following commands:

setenv ISE_EIFFEL /usr/local/EiffelXX
setenv ISE_PLATFORM hpux-11
set path = ($path $ISE_EIFFEL/studio/spec/$ISE_PLATFORM/bin)

If you are using the Enterprise edition, please follow the instructions of the next section, Registering the Enterprise Edition , otherwise jump to the Using EiffelStudio section at the end of this document.

Registering the Enterprise Edition

This step assumes you have followed the instructions in the Setting up EiffelStudio section. Perform the following commands to start the registration process:

cd $ISE_EIFFEL
./register

A dialog asking for your Username and CD Key should appear as it does below:

Enter the information located inside the box that contains your copy of the EiffelStudio Enterprise Edition. Once the information is correct, the Register button will be enabled. Click Register to actually register EiffelStudio.

The first time you launch EiffelStudio, you will be asked for an activation key through the following dialog:

By clicking on the http://activate.eiffel.com URL, a new web browser will appear with the requested fields automatically filled in with the appropriate information. Simply click Activate and a new page with an activation code will appear. Copy and paste the activation code in the first field and the Activate button should be enabled to let you activate your copy.

You can activate your copy up to three times. Once you have reached this threshold and need to reinstall your copy, contact Eiffel Software to request one more activation.

If no web browser appears, it is most likely because firefox is not installed on your machine or is not in your path. Instead you should manually launch a new web browser, go to the page http://activate.eiffel.com , and enter the information manually. Then follow the above instructions as if the browser had been properly launched.

You may receive the following dialog when launching EiffelStudio:

This probably means that the register program was not launched or did not succeed in storing data to the following file $ISE_EIFFEL/install/limand/.ec_license. To solve this, rerun the register program with a user account that has permissions to write at $ISE_EIFFEL/install/limand and enter your Username and CD Key.

Once this is done, you can jump to the next section, Using EiffelStudio .

Using EiffelStudio

Starting EiffelStudio

Now everything should be properly installed and you should be able to run the compiler. Launch estudio for the interactive graphical user interface of the compiler, or launch ec for the command line interface. If you are a new user to EiffelStudio, we recommend that you follow the guided tour.

EiffelStudio Appearance

EiffelStudio for Unix uses the GTK+ theme engine to allow for custom appearance such as changing the default font size and color of windows, etc. If you do not have a theme manager (such as that provided with Gnome) you can copy the .gtkrc-2.0 file from $ISE_EIFFEL/eifinit/studio/spec/gtk directory to your $HOME directory.

HP Tru64 UNIX

Contents 1 Requirements 2 Checking your environment 3 Installing EiffelStudio from the Web 4 Installing EiffelStudio from a CD-ROM 5 Setting up EiffelStudio 6 Registering the Enterprise Edition 7 Using EiffelStudio 7.1 Starting EiffelStudio 7.2 EiffelStudio Appearance

Requirements

Computer/Processor	AlphaServer.
Operating System	HP Tru64 UNIX 5.1B with GTK+ 2.4.
C compiler	HP C compiler
Memory	512MB of RAM (1GB recommended).
Hard Disk	500MB of hard disk space (1GB recommended).
Drive	CD-ROM or DVD drive (not required when downloading EiffelStudio).
Display	1024 x 768 or higher resolution video adapter and monitor.
Peripherals	Keyboard and mouse or compatible pointing device.
ISE_PLATFORM	alpha.

Checking your environment

EiffelStudio requires GTK+ 2.4.0 or above to function properly. You can check that you have this installed correctly by typing the following command: pkg-config --modversion gtk+-2.0 The command should succeed and the version number of GTK+ should appear. If it is not 2.4.0 or above then you cannot continue the installation of EiffelStudio. You first need to install GTK+ 2.4.0.

Installing EiffelStudio from the Web

After downloading the installation package, you should manually extract its contents to your hard drive. For example, you can extract it into /usr/local using the following commands (assuming that you have permission to /usr/local and that the installation package was saved in /tmp/EiffelXX.tar.bz2, where XX stands for the EiffelStudio version):

cd /usr/local
tar xvfj /tmp/EiffelXX.tar.bz2

This will install EiffelStudio files into /usr/local/EiffelXX. Once this is done, jump to the Setting up EiffelStudio section in order to complete the installation of EiffelStudio.

Installing EiffelStudio from a CD-ROM

Insert the CD into your CD-ROM drive. You should manually extract its contents to your hard drive. For example you can extract it in /usr/local using the following commands (assuming that you have permission to /usr/local and that the CD is mounted on /mnt/cdrom):

cd /usr/local
cp -r /mnt/cdrom/EiffelXX .

This will install the EiffelStudio files into /usr/local/EiffelXX. To complete the installation of EiffelStudio, jump to the next section, Setting up EiffelStudio.

Setting up EiffelStudio

Once the files have been installed, you should define the following environment variables in order to run EiffelStudio:

• ISE_EIFFEL to /usr/local/EiffelXX
• ISE_PLATFORM to alpha.

and add $ISE_EIFFEL/studio/spec/$ISE_PLATFORM/bin to your PATH environment variable.

Using sh or bash as a shell, it suffices to type the following commands:

export ISE_EIFFEL=/usr/local/EiffelXX
export ISE_PLATFORM=alpha
export PATH=$PATH:$ISE_EIFFEL/studio/spec/$ISE_PLATFORM/bin

Using csh or tcsh as a shell, it suffices to type the following commands:

setenv ISE_EIFFEL /usr/local/EiffelXX
setenv ISE_PLATFORM alpha
set path = ($path $ISE_EIFFEL/studio/spec/$ISE_PLATFORM/bin)

If you are using the Enterprise edition, please follow the instructions of the next section, Registering the Enterprise Edition, otherwise jump to the Using EiffelStudio section at the end of this document.

Registering the Enterprise Edition

This step assumes you have followed the instructions in the Setting up EiffelStudio section. Perform the following commands to start the registration process:

cd $ISE_EIFFEL
./register

A dialog asking for your Username and CD Key should appear as it does below:

Enter the information located inside the box that contains your copy of the EiffelStudio Enterprise Edition. Once the information is correct, the Register button will be enabled. Click Register to actually register EiffelStudio.

The first time you launch EiffelStudio, you will be asked for an activation key through the following dialog:

By clicking on the http://activate.eiffel.com URL, a new web browser will appear with the requested fields automatically filled in with the appropriate information. Simply click Activate and a new page with an activation code will appear. Copy and paste the activation code in the first field and the Activate button should be enabled to let you activate your copy.

You can activate your copy up to three times. Once you have reached this threshold and need to reinstall your copy, contact Eiffel Software to request one more activation.

If no web browser appears, it is most likely because firefox is not installed on your machine or is not in your path. Instead you should manually launch a new web browser, go to the page http://activate.eiffel.com , and enter the information manually. Then follow the above instructions as if the browser had been properly launched.

You may receive the following dialog when launching EiffelStudio:

This probably means that the register program was not launched or did not succeed in storing data to the following file $ISE_EIFFEL/install/limand/.ec_license. To solve this, rerun the register program with a user account that has permissions to write at $ISE_EIFFEL/install/limand and enter your Username and CD Key.

Once this is done, you can jump to the next section, Using EiffelStudio.

Using EiffelStudio

Starting EiffelStudio

Now everything should be properly installed and you should be able to run the compiler. Launch estudio for the interactive graphical user interface of the compiler, or launch ec for the command line interface. If you are a new user to EiffelStudio, we recommend that you follow the guided tour.

EiffelStudio Appearance

EiffelStudio for Unix uses the GTK+ theme engine to allow for custom appearance such as changing the default font size and color of windows, etc. If you do not have a theme manager (such as that provided with Gnome) you can copy the .gtkrc-2.0 file from $ISE_EIFFEL/eifinit/studio/spec/gtk directory to your $HOME directory.

Linux

Contents 1 Requirements 2 Checking your environment 3 Installing EiffelStudio from the Web 4 Installing EiffelStudio from a CD-ROM 5 Setting up EiffelStudio 6 Registering the Enterprise Edition 7 Using EiffelStudio 7.1 Starting EiffelStudio 7.2 EiffelStudio Appearance

Requirements

Computer/Processor	PC with 300 MHz or higher Pentium II class processor or equivalent recommended.
Operating System	Fedora Core 2, Slackware 10 or any Linux system with glibc 2.3 and either Gnome 2.6 or GTK+ 2.4.
C compiler	gcc
Memory	512MB of RAM (1GB recommended).
Hard Disk	500MB of hard disk space (1GB recommended).
Drive	CD-ROM or DVD drive (not required when downloading EiffelStudio).
Display	1024 x 768 or higher resolution video adapter and monitor.
Peripherals	Keyboard and mouse or compatible pointing device.
ISE_PLATFORM	linux-x86 for x86 based CPU, linux-x86-64 for x64 based CPU.

Checking your environment

EiffelStudio requires GTK+ 2.4.0 or above to function properly. You can check that you have this installed correctly by typing the following command: pkg-config --modversion gtk+-2.0 The command should succeed and the version number of GTK+ should appear. If it is not 2.4.0 or above then you cannot continue the installation of EiffelStudio. You first need to install GTK+ 2.4.0.

On some Linux distribution the Xtst library is required but not installed by default. You have to make sure it is installed by using the instruction of your Linux distribution.

For example, on Debian based distribution you need to do:

sudo apt-get install libgtk2.0-dev
sudo apt-get install libxtst-dev

Installing EiffelStudio from the Web

After downloading the installation package, you should manually extract its contents to your hard drive. For example, you can extract it into /usr/local using the following commands (assuming that you have permission to /usr/local and that the installation package was saved in /tmp/EiffelXX.tar.bz2, where XX stands for the EiffelStudio version):

cd /usr/local
tar xvfj /tmp/EiffelXX.tar.bz2

This will install EiffelStudio files into /usr/local/EiffelXX. Once this is done, jump to the Setting up EiffelStudio section in order to complete the installation of EiffelStudio.

Installing EiffelStudio from a CD-ROM

Insert the CD into your CD-ROM drive. You should manually extract its contents to your hard drive. For example you can extract it in /usr/local using the following commands (assuming that you have permission to /usr/local and that the CD is mounted on /mnt/cdrom):

cd /usr/local
cp -r /mnt/cdrom/EiffelXX .

This will install the EiffelStudio files into /usr/local/EiffelXX. To complete the installation of EiffelStudio, jump to the next section, Setting up EiffelStudio.

Setting up EiffelStudio

Once the files have been installed, you should define the following environment variables in order to run EiffelStudio:

• ISE_EIFFEL to /usr/local/EiffelXX
• ISE_PLATFORM to linux-x86 for the 32 bits version or linux-x86-64 for the 64 bits version. We will be using linux-x86 in the examples below.

and add $ISE_EIFFEL/studio/spec/$ISE_PLATFORM/bin to your PATH environment variable.

Using sh or bash as a shell, it suffices to type the following commands:

export ISE_EIFFEL=/usr/local/EiffelXX
export ISE_PLATFORM=linux-x86
export PATH=$PATH:$ISE_EIFFEL/studio/spec/$ISE_PLATFORM/bin

Using csh or tcsh as a shell, it suffices to type the following commands:

setenv ISE_EIFFEL /usr/local/EiffelXX
setenv ISE_PLATFORM linux-x86
set path = ($path $ISE_EIFFEL/studio/spec/$ISE_PLATFORM/bin)

If you are using the Enterprise edition, please follow the instructions of the next section, Registering the Enterprise Edition, otherwise jump to the Using EiffelStudio section at the end of this document.

Registering the Enterprise Edition

This step assumes you have followed the instructions in the Setting up EiffelStudio section. Perform the following commands to start the registration process:

cd $ISE_EIFFEL
./register

A dialog asking for your Username and CD Key should appear as it does below:

Enter the information located inside the box that contains your copy of the EiffelStudio Enterprise Edition. Once the information is correct, the Register button will be enabled. Click Register to actually register EiffelStudio.

The first time you launch EiffelStudio, you will be asked for an activation key through the following dialog:

By clicking on the http://activate.eiffel.com URL, a new web browser will appear with the requested fields automatically filled in with the appropriate information. Simply click Activate and a new page with an activation code will appear. Copy and paste the activation code in the first field and the Activate button should be enabled to let you activate your copy.

You can activate your copy up to three times. Once you have reached this threshold and need to reinstall your copy, contact Eiffel Software to request one more activation.

If no web browser appears, it is most likely because firefox is not installed on your machine or is not in your path. Instead you should manually launch a new web browser, go to the page http://activate.eiffel.com , and enter the information manually. Then follow the above instructions as if the browser had been properly launched.

You may receive the following dialog when launching EiffelStudio:

This probably means that the register program was not launched or did not succeed in storing data to the following file $ISE_EIFFEL/install/limand/.ec_license. To solve this, rerun the register program with a user account that has permissions to write at $ISE_EIFFEL/install/limand and enter your Username and CD Key.

Once this is done, you can jump to the next section, Using EiffelStudio .

Using EiffelStudio

Starting EiffelStudio

Now everything should be properly installed and you should be able to run the compiler. Launch estudio for the interactive graphical user interface of the compiler, or launch ec for the command line interface. If you are a new user to EiffelStudio, we recommend that you follow the guided tour.

EiffelStudio Appearance

EiffelStudio for Unix uses the GTK+ theme engine to allow for custom appearance such as changing the default font size and color of windows, etc. If you do not have a theme manager (such as that provided with Gnome) you can copy the .gtkrc-2.0 file from $ISE_EIFFEL/eifinit/studio/spec/gtk directory to your $HOME directory.

LinuxPPC

Contents 1 Requirements 2 Checking your environment 3 Installing EiffelStudio from the Web 4 Installing EiffelStudio from a CD-ROM 5 Setting up EiffelStudio 6 Registering the Enterprise Edition 7 Using EiffelStudio 7.1 Starting EiffelStudio 7.2 EiffelStudio Appearance

Requirements

Computer/Processor	PowerPC.
Operating System	Yellow Dog Linux 4.0 with either Gnome 2.6 or GTK+ 2.4.
C compiler	gcc
Memory	512MB of RAM (1GB recommended).
Hard Disk	500MB of hard disk space (1GB recommended).
Drive	CD-ROM or DVD drive (not required when downloading EiffelStudio).
Display	1024 x 768 or higher resolution video adapter and monitor.
Peripherals	Keyboard and mouse or compatible pointing device.
ISE_PLATFORM	linux-ppc.

Checking your environment

EiffelStudio requires GTK+ 2.4.0 or above to function properly. You can check that you have this installed correctly by typing the following command: pkg-config --modversion gtk+-2.0 The command should succeed and the version number of GTK+ should appear. If it is not 2.4.0 or above then you cannot continue the installation of EiffelStudio. You first need to install GTK+ 2.4.0.

Installing EiffelStudio from the Web

After downloading the installation package, you should manually extract its contents to your hard drive. For example, you can extract it into /usr/local using the following commands (assuming that you have permission to /usr/local and that the installation package was saved in /tmp/EiffelXX.tar.bz2, where XX stands for the EiffelStudio version):

cd /usr/local
tar xvfj /tmp/EiffelXX.tar.bz2

This will install EiffelStudio files into /usr/local/EiffelXX. Once this is done, jump to the Setting up EiffelStudio section in order to complete the installation of EiffelStudio.

Installing EiffelStudio from a CD-ROM

Insert the CD into your CD-ROM drive. You should manually extract its contents to your hard drive. For example you can extract it in /usr/local using the following commands (assuming that you have permission to /usr/local and that the CD is mounted on /mnt/cdrom):

cd /usr/local
cp -r /mnt/cdrom/EiffelXX .

This will install the EiffelStudio files into /usr/local/EiffelXX. To complete the installation of EiffelStudio, jump to the next section, Setting up EiffelStudio.

Setting up EiffelStudio

Once the files have been installed, you should define the following environment variables in order to run EiffelStudio:

• ISE_EIFFEL to /usr/local/EiffelXX
• ISE_PLATFORM to linux-ppc.

and add $ISE_EIFFEL/studio/spec/$ISE_PLATFORM/bin to your PATH environment variable.

Using sh or bash as a shell, it suffices to type the following commands:

export ISE_EIFFEL=/usr/local/EiffelXX
export ISE_PLATFORM=linux-ppc
export PATH=$PATH:$ISE_EIFFEL/studio/spec/$ISE_PLATFORM/bin

Using csh or tcsh as a shell, it suffices to type the following commands:

setenv ISE_EIFFEL /usr/local/EiffelXX
setenv ISE_PLATFORM linux-ppc
set path = ($path $ISE_EIFFEL/studio/spec/$ISE_PLATFORM/bin)

If you are using the Enterprise edition, please follow the instructions of the next section, Registering the Enterprise Edition, otherwise jump to the Using EiffelStudio section at the end of this document.

Registering the Enterprise Edition

This step assumes you have followed the instructions in the [[#Setting up EiffelStudio|Setting up EiffelStudio] section. Perform the following commands to start the registration process:

cd $ISE_EIFFEL
./register

A dialog asking for your Username and CD Key should appear as it does below:

Enter the information located inside the box that contains your copy of the EiffelStudio Enterprise Edition. Once the information is correct, the Register button will be enabled. Click Register to actually register EiffelStudio.

The first time you launch EiffelStudio, you will be asked for an activation key through the following dialog:

By clicking on the http://activate.eiffel.com URL, a new web browser will appear with the requested fields automatically filled in with the appropriate information. Simply click Activate and a new page with an activation code will appear. Copy and paste the activation code in the first field and the Activate button should be enabled to let you activate your copy.

You can activate your copy up to three times. Once you have reached this threshold and need to reinstall your copy, contact Eiffel Software to request one more activation.

If no web browser appears, it is most likely because firefox is not installed on your machine or is not in your path. Instead you should manually launch a new web browser, go to the page http://activate.eiffel.com , and enter the information manually. Then follow the above instructions as if the browser had been properly launched.

You may receive the following dialog when launching EiffelStudio:

This probably means that the register program was not launched or did not succeed in storing data to the following file $ISE_EIFFEL/install/limand/.ec_license. To solve this, rerun the register program with a user account that has permissions to write at $ISE_EIFFEL/install/limand and enter your Username and CD Key.

Once this is done, you can jump to the next section, Using EiffelStudio.

Using EiffelStudio

Starting EiffelStudio

Now everything should be properly installed and you should be able to run the compiler. Launch estudio for the interactive graphical user interface of the compiler, or launch ec for the command line interface. If you are a new user to EiffelStudio, we recommend that you follow the guided tour.

EiffelStudio Appearance

EiffelStudio for Unix uses the GTK+ theme engine to allow for custom appearance such as changing the default font size and color of windows, etc. If you do not have a theme manager (such as that provided with Gnome) you can copy the .gtkrc-2.0 file from $ISE_EIFFEL/eifinit/studio/spec/gtk directory to your $HOME directory.

Windows

Contents 1 Requirements 2 Installing EiffelStudio from the Web 3 Installing the Enterprise Edition. 4 .NET Support 5 What about Windows 95, 98 and Me? 6 Starting EiffelStudio

Requirements

Computer/Processor	PC with 1GHz or higher Intel/AMD processor or equivalent recommended.
Operating System	Windows 2000/XP/2003/Vista/Win7.
C compiler	Microsoft Visual Studio 2005 or greater, or using MinGW (gcc) included in the EiffelStudio delivery
Memory	512MB of RAM (1GB recommended).
Hard Disk	500MB of hard disk space (1GB recommended). Hard disk space requirements will vary depending on configuration; custom installation choices may require more or less space. Space required for installation of the Microsoft .NET Framework will also be required.
Drive	CD-ROM drive (not required when downloading EiffelStudio).
Display	1024 x 768 or higher resolution video adapter and monitor.
Peripherals	Keyboard and mouse or compatible pointing device.
ISE_PLATFORM	windows for 32 bits version of Windows, win64 for 64 bits version of Windows.

Installing EiffelStudio from the Web

After downloading the EiffelXX.msi installation package, right click on it and select Install. This will launch the installation procedure. Follow the steps indicated in the dialogs to complete the installation.

Installing the Enterprise Edition.

Insert the CD into your CD-ROM drive. If you have the autorun facility enabled, the installation process will automatically be launched. Otherwise you can launch it by executing EiffelXX.msi located at the root of the CD. During the installation you will be asked for your Username and CD Key

Enter the information located inside the box that contains your copy of the EiffelStudio Enterprise Edition, or that you will have received via email. Once the information is correct, the Next button will be enabled. Click Next and follow the steps indicated in the dialogs to complete the installation.

Once installed, the first time you launch EiffelStudio, you will be asked for an activation key through the following dialog:

By clicking on the http://activate.eiffel.com URL, a new web browser will appear with the requested fields automatically filled in with the appropriate information. Simply click Activate and a new page with an activation code will appear. Copy and paste the activation code in the first field and the Activate button should be enabled to let you activate your copy.

You can activate your copy up to three times. Once you have reached this threshold and need to reinstall your copy, contact Eiffel Software to request one more activation.

You may receive the following dialog when launching EiffelStudio:

This probably means that EiffelStudio was not properly installed using the setup.exe program. Uninstall EiffelStudio and rerun the installation procedure by making sure to launch setup.exe and enter your Username and CD Key.

.NET Support

To enable .NET support in EiffelStudio, it is necessary to install the Microsoft .NET Framework prior to starting the installation of EiffelStudio. EiffelStudio currently supports all the versions of the .NET Framework up to 4.0.

What about Windows 95, 98 and Me?

EiffelStudio will not run on Windows 95, 98 and Me. Contact Eiffel Software directly if you need support for those OSes. EiffelStudio generated code could run on 95, 98 and Me if no UI is being used. If the UI is used it could run but it requires installing the Microsoft Layer for Unicode.

Starting EiffelStudio

Now everything should be properly installed and you should be able to run the compiler. You can now launch EiffelStudio from the Start menu or from the EiffelStudio shortcut on your desktop. If you are a new user to EiffelStudio, we recommend that you follow the guided tour .

SGI Irix

Contents 1 Requirements 2 Checking your environment 3 Installing EiffelStudio from the Web 4 Installing EiffelStudio from a CD-ROM 5 Setting up EiffelStudio 6 Registering the Enterprise Edition 7 Using EiffelStudio 7.1 Starting EiffelStudio 7.2 EiffelStudio Appearance

Requirements

Computer/Processor	MIPS.
Operating System	Irix 6.5 with either Gnome 2.6 or GTK+ 2.4.
C compiler	MIPSPro C compiler V2.4 or later.
Memory	512MB of RAM (1GB recommended).
Hard Disk	500MB of hard disk space (1GB recommended).
Drive	CD-ROM or DVD drive (not required when downloading EiffelStudio).
Display	1024 x 768 or higher resolution video adapter and monitor.
Peripherals	Keyboard and mouse or compatible pointing device.
ISE_PLATFORM	irix-mips for 32 bits, irix-mips-64 for 64 bits.

Checking your environment

EiffelStudio requires GTK+ 2.4.0 or above to function properly. You can check that you have this installed correctly by typing the following command: pkg-config --modversion gtk+-2.0 The command should succeed and the version number of GTK+ should appear. If it is not 2.4.0 or above then you cannot continue the installation of EiffelStudio. You first need to install GTK+ 2.4.0.

Installing EiffelStudio from the Web

After downloading the installation package, you should manually extract its contents to your hard drive. For example, you can extract it into /usr/local using the following commands (assuming that you have permission to /usr/local and that the installation package was saved in /tmp/EiffelXX.tar.bz2, where XX stands for the EiffelStudio version):

cd /usr/local
tar xvfj /tmp/EiffelXX.tar.bz2

This will install EiffelStudio files into /usr/local/EiffelXX. Once this is done, jump to the Setting up EiffelStudio section in order to complete the installation of EiffelStudio.

Installing EiffelStudio from a CD-ROM

Insert the CD into your CD-ROM drive. You should manually extract its contents to your hard drive. For example you can extract it in /usr/local using the following commands (assuming that you have permission to /usr/local and that the CD is mounted on /mnt/cdrom):

cd /usr/local
cp -r /mnt/cdrom/EiffelXX .

This will install the EiffelStudio files into /usr/local/EiffelXX. To complete the installation of EiffelStudio, jump to the next section, Setting up EiffelStudio.

Setting up EiffelStudio

Once the files have been installed, you should define the following environment variables in order to run EiffelStudio:

• ISE_EIFFEL to /usr/local/EiffelXX
• ISE_PLATFORM to irix-mips for the 32 bits version or irix-mips-64 for the 64 bits version. We will be using irix-mips in the examples below.

and add $ISE_EIFFEL/studio/spec/$ISE_PLATFORM/bin to your PATH environment variable.

Using sh or bash as a shell, it suffices to type the following commands:

export ISE_EIFFEL=/usr/local/EiffelXX
export ISE_PLATFORM=irix-mips
export PATH=$PATH:$ISE_EIFFEL/studio/spec/$ISE_PLATFORM/bin

Using csh or tcsh as a shell, it suffices to type the following commands:

setenv ISE_EIFFEL /usr/local/EiffelXX
setenv ISE_PLATFORM irix-mips
set path = ($path $ISE_EIFFEL/studio/spec/$ISE_PLATFORM/bin)

If you are using the Enterprise edition, please follow the instructions of the next section, Registering the Enterprise Edition, otherwise jump to the Using EiffelStudio section at the end of this document.

Registering the Enterprise Edition

This step assumes you have followed the instructions in the Setting up EiffelStudio section. Perform the following commands to start the registration process:

cd $ISE_EIFFEL
./register

A dialog asking for your Username and CD Key should appear as it does below:

Enter the information located inside the box that contains your copy of the EiffelStudio Enterprise Edition. Once the information is correct, the Register button will be enabled. Click Register to actually register EiffelStudio.

The first time you launch EiffelStudio, you will be asked for an activation key through the following dialog:

By clicking on the http://activate.eiffel.com URL, a new web browser will appear with the requested fields automatically filled in with the appropriate information. Simply click Activate and a new page with an activation code will appear. Copy and paste the activation code in the first field and the Activate button should be enabled to let you activate your copy.

You can activate your copy up to three times. Once you have reached this threshold and need to reinstall your copy, contact Eiffel Software to request one more activation.

If no web browser appears, it is most likely because firefox is not installed on your machine or is not in your path. Instead you should manually launch a new web browser, go to the page http://activate.eiffel.com , and enter the information manually. Then follow the above instructions as if the browser had been properly launched.

You may receive the following dialog when launching EiffelStudio:

This probably means that the register program was not launched or did not succeed in storing data to the following file $ISE_EIFFEL/install/limand/.ec_license. To solve this, rerun the register program with a user account that has permissions to write at $ISE_EIFFEL/install/limand and enter your Username and CD Key.

Once this is done, you can jump to the next section, Using EiffelStudio.

Using EiffelStudio

Starting EiffelStudio

Now everything should be properly installed and you should be able to run the compiler. Launch estudio for the interactive graphical user interface of the compiler, or launch ec for the command line interface. If you are a new user to EiffelStudio, we recommend that you follow the guided tour.

EiffelStudio Appearance

EiffelStudio for Unix uses the GTK+ theme engine to allow for custom appearance such as changing the default font size and color of windows, etc. If you do not have a theme manager (such as that provided with Gnome) you can copy the .gtkrc-2.0 file from $ISE_EIFFEL/eifinit/studio/spec/gtk directory to your $HOME directory.

Solaris

Contents 1 Requirements 2 Checking your environment 3 Installing EiffelStudio from the Web 4 Installing EiffelStudio from a CD-ROM 5 Setting up EiffelStudio 6 Registering the Enterprise Edition 7 Using EiffelStudio 7.1 Starting EiffelStudio 7.2 EiffelStudio Appearance

Requirements

Computer/Processor	UltraSparc.
Operating System	Solaris 9.0 or greater for Sparc, Solaris 10 or greater for x86 with either Gnome 2.6 or GTK+ 2.4.
C compiler	Sun Studio 12 C compiler
Memory	512MB of RAM (1GB recommended).
Hard Disk	500MB of hard disk space (1GB recommended).
Drive	CD-ROM or DVD drive (not required when downloading EiffelStudio).
Display	1024 x 768 or higher resolution video adapter and monitor.
Peripherals	Keyboard and mouse or compatible pointing device.
ISE_PLATFORM	solaris-sparc for 32 bits version of Solaris on Sparc processor, solaris-sparc-64 for 64 bits versions, solaris-x86 and solaris-x86-64 for the Intel processor on 32 and 64 bits.

Checking your environment

EiffelStudio requires GTK+ 2.4.0 or above to function properly. You can check that you have this installed correctly by typing the following command: pkg-config --modversion gtk+-2.0 The command should succeed and the version number of GTK+ should appear. If it is not 2.4.0 or above then you cannot continue the installation of EiffelStudio. You first need to install GTK+ 2.4.0.

EiffelStudio requires the library file libmlib.so.2. If this file is missing from your Solaris installation, you can install it by installing medialib.

Installing EiffelStudio from the Web

After downloading the installation package, you should manually extract its contents to your hard drive. For example, you can extract it into /usr/local using the following commands (assuming that you have permission to /usr/local and that the installation package was saved in /tmp/EiffelXX.tar.bz2, where XX stands for the EiffelStudio version):

cd /usr/local
tar xvfj /tmp/EiffelXX.tar.bz2

This will install EiffelStudio files into /usr/local/EiffelXX. Once this is done, jump to the Setting up EiffelStudio section in order to complete the installation of EiffelStudio.

Installing EiffelStudio from a CD-ROM

Insert the CD into your CD-ROM drive. You should manually extract its contents to your hard drive. For example you can extract it in /usr/local using the following commands (assuming that you have permission to /usr/local and that the CD is mounted on /mnt/cdrom):

cd /usr/local
cp -r /mnt/cdrom/EiffelXX .

This will install the EiffelStudio files into /usr/local/EiffelXX. To complete the installation of EiffelStudio, jump to the next section, Setting up EiffelStudio .

Setting up EiffelStudio

Once the files have been installed, you should define the following environment variables in order to run EiffelStudio:

• ISE_EIFFEL to /usr/local/EiffelXX
• ISE_PLATFORM to solaris-sparc for the 32 bits version or solaris-sparc-64 for the 64 bits version, respectively solaris-x86 and solaris-x86-64 for Solaris on Intel processors. We will be using solaris-sparc in the examples below.

and add $ISE_EIFFEL/studio/spec/$ISE_PLATFORM/bin to your PATH environment variable.

Using sh or bash as a shell, it suffices to type the following commands:

export ISE_EIFFEL=/usr/local/EiffelXX
export ISE_PLATFORM=solaris-sparc
export PATH=$PATH:$ISE_EIFFEL/studio/spec/$ISE_PLATFORM/bin

Using csh or tcsh as a shell, it suffices to type the following commands:

setenv ISE_EIFFEL /usr/local/EiffelXX
setenv ISE_PLATFORM solaris-sparc
set path = ($path $ISE_EIFFEL/studio/spec/$ISE_PLATFORM/bin)

If you are using the Enterprise edition, please follow the instructions of the next section, Registering the Enterprise Edition , otherwise jump to the Using EiffelStudio section at the end of this document.

Registering the Enterprise Edition

This step assumes you have followed the instructions in the Setting up EiffelStudio section. Perform the following commands to start the registration process:

cd $ISE_EIFFEL
./register

A dialog asking for your Username and CD Key should appear as it does below:

Enter the information located inside the box that contains your copy of the EiffelStudio Enterprise Edition. Once the information is correct, the Register button will be enabled. Click Register to actually register EiffelStudio.

The first time you launch EiffelStudio, you will be asked for an activation key through the following dialog:

By clicking on the http://activate.eiffel.com URL, a new web browser will appear with the requested fields automatically filled in with the appropriate information. Simply click Activate and a new page with an activation code will appear. Copy and paste the activation code in the first field and the Activate button should be enabled to let you activate your copy.

You can activate your copy up to three times. Once you have reached this threshold and need to reinstall your copy, contact Eiffel Software to request one more activation.

If no web browser appears, it is most likely because firefox is not installed on your machine or is not in your path. Instead you should manually launch a new web browser, go to the page http://activate.eiffel.com , and enter the information manually. Then follow the above instructions as if the browser had been properly launched.

You may receive the following dialog when launching EiffelStudio:

This probably means that the register program was not launched or did not succeed in storing data to the following file $ISE_EIFFEL/install/limand/.ec_license. To solve this, rerun the register program with a user account that has permissions to write at $ISE_EIFFEL/install/limand and enter your Username and CD Key.

Once this is done, you can jump to the next section, Using EiffelStudio .

Using EiffelStudio

Starting EiffelStudio

Now everything should be properly installed and you should be able to run the compiler. Launch estudio for the interactive graphical user interface of the compiler, or launch ec for the command line interface. If you are a new user to EiffelStudio, we recommend that you follow the guided tour .

EiffelStudio Appearance

EiffelStudio for Unix uses the GTK+ theme engine to allow for custom appearance such as changing the default font size and color of windows, etc. If you do not have a theme manager (such as that provided with Gnome) you can copy the .gtkrc-2.0 file from $ISE_EIFFEL/eifinit/studio/spec/gtk directory to your $HOME directory.

Third Party Tools Installation Help

Here you can find help for installing third party tools and programs which may be necessary for your Eiffel programming needs.

Free Microsoft C Compiler

EiffelStudio: Starting a project

Browsing

Editing a project

Compiling

Running and debugging

            debug("MY_DEBUG_FLAG")
                -- Debug code is here.
            end

        local
            ps: PROFILING_SETTING
                -- Other local variables if necessary.
        do
            create ps.make
            ps.stop_profiling
                -- Real program execution.
            ps.start_profiling
        end

        local
            ps: PROFILING_SETTING
                -- Other local variables if necessary.
        do
            create ps.make
            ps.start_profiling
                -- What needs to be profiled.
            ps.stop_profiling
        end

        local
            ts: TRACING_SETTING
                -- Other local variables if necessary.
        do
            create ts.make
            ps.disable_tracing
                -- Program execution continues.
                    ...
 
                -- Restore tracing before exiting for proper cleanup.
             ps.enable_tracing
        end

        local
            ts: TRACING_SETTING
                -- Other local variables if necessary.
        do
            create ts.make
            ps.enable_tracing    -- Enable trace
                    -- Section needing trace.
                ...
            ps.disable_tracing    -- Disable trace
        end

    trace (a_type_id: INTEGER; a_c_class_name, a_c_feature_name: POINTER; a_depth: INTEGER; a_is_entering: BOOLEAN)
            -- Trigger a trace operation from a feature represented by `a_c_feature_name' defined in
            -- class `a_c_class_name' and applied to an object of type `a_type_id' at a call depth `a_depth'.
            -- If `a_is_entering' we are entering the routine, otherwise we are exiting it.			
        require
            a_type_id_non_negative: a_type_id >= 0
            a_depth_non_negative: a_depth >= 0
        deferred
        end

    trace (a_type: TYPE [detachable ANY]; a_class_name, a_feature_name: detachable STRING; a_depth: INTEGER; a_is_entering: BOOLEAN)
            -- Trigger a trace operation from a feature represented by `a_feature_name' defined in
            -- class `a_class_name' and applied to an object of type `a_type' at a call depth `a_depth'.
            -- If `a_is_entering' we are entering the routine, otherwise we are exiting it.			
        require
            a_depth_non_negative: a_depth >= 0
         deferred
        end

class
    EXAMPLE_HANDLER
inherit
    STRING_TRACING_HANDLER
 
feature
 
    trace (a_type: TYPE [ANY]; a_class_name, a_feature_name: STRING_8; a_depth: INTEGER_32; a_is_entering: BOOLEAN)
            -- <Precursor>
        do
            trace_log_file.put_string (create {STRING}.make_filled ('>', a_depth))
            if a_is_entering then
                trace_log_file.put_string (" Is entering " + "{" + a_class_name + "}." + a_feature_name + "%N")
            else
                trace_log_file.put_string (" Is leaving  " + "{" + a_class_name + "}." + a_feature_name + "%N")
            end
        end
 
    trace_log_file: PLAIN_TEXT_FILE 
            -- Log file
        once
            create Result.make_open_write ("my_log_file.txt")
        end
 
    close_log_file
            -- Close log file
        do
            trace_log_file.close
        end
end

class
    APPLICATION
 
create
    make
 
feature
 
    make
            -- Run application.
        local
            tracing_setting: TRACING_SETTING
            tracing_handler: EXAMPLE_HANDLER
        do
            create tracing_setting
            tracing_setting.enable_tracing
            create tracing_handler
            tracing_handler.activate
 
            call_depth_one
 
            tracing_handler.deactivate
            tracing_handler.close_log_file
            tracing_setting.disable_tracing
    end
 
    call_depth_one
            -- Call depth one routine
        do
            call_depth_two
        end
 
    call_depth_two
            -- Call depth two routine
        do
            call_depth_three
        end
 
    call_depth_three
            -- Call depth three routine
        do
 
        end
end

> Is entering {APPLICATION}.call_depth_one
>> Is entering {APPLICATION}.call_depth_two
>>> Is entering {APPLICATION}.call_depth_three
>>> Is leaving  {APPLICATION}.call_depth_three
>> Is leaving  {APPLICATION}.call_depth_two
> Is leaving  {APPLICATION}.call_depth_one

Designing a project

Undoing and redoing

Almost all actions in the diagram tool are undoable. Every action that can be undone, can also be redone. For advanced undoing, open the history tool.

Tip: Undo actions cannot be undone. Use redo to undo an undo action.

• To undo the last action, click Undo last action.
• To redo the last action, click Redo last action.
• To undo all actions up until a specific action:
  1. Click the History tool button.
  2. The History tool dialog appears with a list of all undoable actions. By clicking on one of the actions, the diagram returns to the state it was in just after you performed this action.

Note: When an action is performed that cannot be undone, the history tool is emptied.

How to analyze a project

The metric tab in the context tool allows project analyzing. Built on a suitable metric theory, this tool provides a set of elementary metrics that can be evaluated to test projects design and implementation.

The metric tool provides an interface to evaluate measures, save them or delete some of them when no longer needed.

Generating documentation

Customizing EiffelStudio

svn up $file_name

svn add $file_name

svn revert $file_name

echo Revert changes to $class_name? && pause && svn revert $file_name

Overview and Prerequisites

EiffelStudio is the central tool of Eiffel Software's implementation of Eiffel, letting you design, develop, debug, document, measure, maintain, test, revise and expand systems using the full power of object technology and Design by Contract™.

This guided tour introduces the essential properties of EiffelStudio. It will take you through a tour of the environment, using a pre-existing example system.

What will I achieve?

Although it skips many specific or advanced facilities, this Tour will help you quickly become familiar with the way you can use the environment for your work. After reading it you will know the basics of working with EiffelStudio:

• Starting a project and retrieving an existing project.
• Entering new software elements -- clusters, classes and features.
• Compiling your software.
• Making changes and recompiling them immediately using the Melting Ice Technology™.
• Displaying a graphical representation of your software elements, and modifying the software through the graphical views (as well as through its text).
• Producing extensive documentation of your system, textual or graphical, under many different formats such as HTML, RTF, Postscript, XMI (for example Rational Rose) and others.
• Browsing through simple or complex software systems, to find out their various components, properties and relationships.
• Measuring quantitative properties of the software, by applying metrics predefined in EiffelStudio as well as new ones that you define.
• Executing a compiled system.
• Controlling execution through the debugging mechanisms of EiffelStudio.
• Creating an effective test suite, with the automated assistance of AutoTest
• Add licensing text to your classes automatically.

About the scope of EiffelStudio

The most important property to keep in mind as you are discovering EiffelStudio is that it is neither just a "programming environment" nor just a "CASE tool" (Computer-Aided Software Engineering) for analysis and design. It encompasses both of these functions and many others. Most system builders today are used to a dichotomy between the high end and the low end:

• At the analysis and design levels, graphical tools help you clarify your thinking about the system, interacting with customers and end users, and devise high-level system architectures, usually in diagrammatic form.
• At the low end, programming tools help you edit, compile and debug your programs.

Keeping these tools separate is, however, detrimental to the quality of the software process and the resulting products. If they are in the hands of different teams, communication problems may arise, leading to discrepancies between need and realization; this can be a source of bugs or even project failure. If it's the same people using tools of both kinds, they have to keep switching notations, tools and modes of thinking. The use of different frameworks at both ends makes it difficult to keep the high-level model and the implementation consistent; too often, a change decided at the implementation level is not reflected back in the higher model. After a while, the system gets into the state of disorder and inconsistency that good tools are precisely meant to avoid.

EiffelStudio, in line with the principles of seamless development and reversibility of the Eiffel method, removes the gap by providing a single set of tools that accompany you throughout a project, from the most high-level initial stages to the most low-level aspects of implementation and maintenance.

This generality is reflected throughout the environment by, for example, the dual use of text and graphics. As another example, you should think of the EiffelStudio compiler, not just as a tool for executing Eiffel software in its final form, but also, thanks to its extensive validity checking facilities, as a design consistency tool that performs many verifications commonly associated with CASE tools.

Depending on your project needs, you may take advantage of EiffelStudio's versatility to address specific purposes:

• You may use EiffelStudio as a programming environment, with advanced tools for compiling, browsing and debugging.
• Some people use EiffelStudio as a modeling tool only, building system descriptions consisting only of deferred (abstract) classes with no implementation, and relying on the Diagram Tool to build, present and discuss these descriptions through graphical views.
• You may use EiffelStudio in both capacities, taking advantage of the seamlessness between all the affected phases.

Learning by doing

If you have access to EiffelStudio as you read this Tour, the most effective technique is to execute all the suggested operations as you read about them.

Please execute user actions, such as clicking, only when asked to do so.

What should I already know?

This Tour assumes very little about what you know and what you don't.

It does assume that you can do simple manipulations on your platform of choice, such as: on Windows, finding and drag-and-dropping folders and files in the Windows Explorer; on Unix, changing to a certain directory ( cd ) and listing the files of a directory ( ls ).

The more you already know about object technology and object-oriented environments, the better. But remember, if you have used other environments before, keep a fresh outlook; EiffelStudio is different, and it may take a while before you fully understand why it does some things in a certain way.

A note on platform differences

EiffelStudio is one of the most portable environments in the industry, running in an almost identical fashion on Windows, on the new Microsoft .NET environment, on many variants of Unix, on Linux, on OpenVMS.

Once an EiffelStudio session has been started, you can largely forget about the operating system. But a few operations -- mostly at the beginning, to launch EiffelStudio -- require platform-dependent mechanisms: starting a program, traversing the file structure, selecting a file. These cases will be marked accordingly below.

Windows users should particularly note the following two conventions of terminology:

• Operating systems store files into hierarchically nested structures called folders or directories. Although "folder" is the more common term for Windows, we will mostly speak of "directories". It's exactly the same thing.
• A file has a full path name, used to describe how to reach it from the root of its file system, as in c:\d1\d2\f . This example uses the Windows notation, which separates successive components of a path name by a backward slash character \ . On Unix and Linux, the separator is a forward slash / , as in /d1/d2/f ; this is also the convention on the Internet for denoting addresses (URLs). Most file names in this manual appear in this Unix/Internet style. On Windows you will normally have to use the backslash convention, although EiffelStudio also accepts forward slashes. In any case you must be consistent: don't mix backward and forward slashes in the same path name. Also note that some names, such as those of object files to be linked with your system, will be passed to outside tools -- C compilers, loaders -- that may not accept the forward slash.

OpenVMS users may similarly use either the Unix convention or the specific OpenVMS path naming convention.

If you are a one-platform person, just ignore, for the next few pages, all references to any platform other than your heart's favorite. They will quickly go away.

What should I have done first?

To run the example you must have installed EiffelStudio and set up the environment. Check in particular the following:

• On Windows, you must have run the installation procedure; it will have put EiffelStudio in the Programs section of the start menu, subsection "EiffelStudio version", where version is the version number, e.g. 6.0.
• The environment variable  ISE_EIFFEL must be set to the installation directory, and the environment variable ISE_PLATFORM to the platform. On Windows this is taken care of automatically by the installation procedure, but on Unix/Linux and OpenVMS you must update your path and environment manually. Throughout this discussion the notations $ISE_EIFFEL and $ISE_PLATFORM will refer to the values of these variables -- the installation directory, and the platform. (The Windows notation would be %ISE_EIFFEL% and %ISE_PLATFORM%.)
• On Unix/Linux and OpenVMS, your "path" must include the place where EiffelStudio executables reside. (On Windows the installation procedure takes care of this.)
• Also, the discussion assumes that as part of the installation you have included the EiffelBase library, in precompiled form. EiffelBase is automatically included if you have installed another precompiled library, such as WEL, the Windows Eiffel Library. The installation procedure takes care of precompiling EiffelBase.

Locating the example

Please take a moment to locate the example files on your installation. They all appear in the following directory, part of the Eiffel delivery: $ISE_EIFFEL/examples/studio/tour

(Windows users: remember that instead of the slash / your platform uses a backslash \ . OpenVMS users: this is to be replaced by the OpenVMS path naming conventions.)

See Also: For a quick introduction to EiffelStudio, see the online EiffelStudio presentation available on the Eiffel Software developers' presentations web page.

Copying the Example Files

Note: If you are using Eiffel on a personal computer, you have the option of working directly in the installation directory and would not necessarily need to make copies of files as per the present section. If you choose to work directly in the installation directory, skip this section and go on to the next section, Starting EiffelStudio and Opening a Project. If you work under Unix or OpenVMS, or may have to share the Eiffel installation with other users, do not have write permissions on the installation, or want to keep the installation unchanged, then please do read the present section and apply its instructions.

If you are going to work on a copy, choose or create a directory of your own; let's call it YOURDIR for the rest of the discussion.

To copy all the files of the example to YOURDIR:

• On Windows, open a Windows Explorer, go to $ISE_EIFFEL\examples\studio\tour , select all the files in that directory, and drag-and-drop them to YOURDIR .
• On Unix execute the shell command

cp $ISE_EIFFEL/examples/studio/tour/* YOURDIR

• On OpenVMS execute the command

copy $ISE_EIFFEL:[examples.studio.tour]*.* YOURDIR

Starting EiffelStudio and Opening a Project

In the rest of this Tour YOURDIR denotes the directory where the example resides (the original, $ISE_EIFFEL/examples/studio/tour , or a copy). Launching will use the operating system's mechanism for starting a program, so we look separately at Windows and at Unix/OpenVMS.

Launching EiffelStudio under Window

On Windows, you can launch EiffelStudio from the Start Menu by following the path:

Start --> Programs --> EiffelStudio Version --> EiffelStudio

where Version is the version number, e.g. 6.5. Alternatively, you can double-click the icon that the installation procedure will have added to your desktop (if you have selected that option during installation).

If this is the first time you are using EiffelStudio, you may get a dialog asking for an unlock code or inviting you to register the product. See your platform installation instructions for registration information.

Launching EiffelStudio under Unix or OpenVMS

To launch EiffelStudio on Unix or OpenVMS, change directory to YOURDIR and, from the command line, type

estudio

In general you can start EiffelStudio from any directory, but to make things simple for this Tour please make sure indeed to execute the estudio command from YOURDIR. (This will allow us to use relative rather than absolute names for some of the files involved.)

Compiling and Executing a System

EiffelStudio first comes up with a window and a dialog on top of it; the dialog looks like this (from here on the look-and-feel will be slightly different on platforms other than Windows, but the content will be the same):

As this is our first project we want to "Add Project...". We could also

• "Create project", which would let you select one among the common schemes -- basic application, graphical Windows application, graphical multi-platform application, Microsoft .NET application -- and set up everything for you.
• "Open project", which would let you open a previously added project.

In future sessions you'll probably use "Create project" for a new project, as it takes care of generating a root class and configuration file for you, and Open project" to open an existing project.

Right now you first have to add the project, so click on the Add Project... button. This brings up a File Explorer inviting you to select an ECF file. The file you want is the file

	simple.ecf

in the directory "YOURDIR", (either $ISE_EIFFEL\examples\studio\tour or the copy that you have made). The ".ecf" file is an Eiffel Configuration File which contains the information necessary for construction of an Eiffel project.

So, use the File Explorer to find and select the file simple.ecf.

Click the button labeled Open to confirm. This starts compilation of your project.

During Eiffel compilation, you can observe the successive compilation steps, or "degrees", in the Outputs tool. The bulk of our little project is the EiffelBase library, which the EiffelStudio installation procedure has precompiled; as a result, there are only a few extra classes to compile, and the process is almost instantaneous on a state-of-the-art computer.

Note: As a frame of reference, on a Toshiba Satellite laptop, mobile dual core 1.73 GHz, 1 GB memory, running Windows Vista, this Eiffel compilation takes about 3.5 seconds.

After Eiffel compilation completes you will see the message

	Eiffel Compilation Succeeded

At this stage your project has finished compiling.

So, congratulations! You have successfully compiled your first Eiffel project. More precisely your project has been "melted". Strange terminology, you may think; in a later section we'll see the derivation of the names used in the compilation process.

Executing the system

Our system doesn't do anything very exciting, but let's execute it anyway. Find and click the Run button ( ) on the toolbar at the top of the EiffelStudio window.

This little application doesn't use graphics or any other fancy stuff. It simply creates some objects and displays some information. Output is accomplished by using the default Eiffel I/O features (from the EiffelBase classes ANY and STANDARD_FILES), and that output goes to a console. On Unix/Linux and OpenVMS it's the window from which you started EiffelStudio. On Windows, by default, it's a new console window that comes up when and if the system does its first output operation, and stays up you dismiss it:

The message "Press Return to finish the execution..." would not appear if you executed the system from outside of EiffelStudio, for example from a command line. Its purpose within EiffelStudio is clear: to let you see the console output; without it, the console would go away at the end of execution. (None of this applies to Unix/Linux/OpenVMS because no new console window was created when we executed the system.)

Before closing the console window, if you look at the main EiffelStudio window (by moving the console window aside) you will notice that it looks different than it did before. This is because EiffelStudio is now in debug mode, so it shows the fields useful in monitoring, controlled execution, and debugging. But we'll look at all this later. For the moment just dismiss the console by following the advice to "Press Return to finish the execution...": hit the Return or Enter key.

A Look at the Project Directory

Before we proceed with the facilities of the environment, let's take a look at the way EiffelStudio organizes project files.

With EiffelStudio, you build projects. Most projects yield an executable system, although you can also build a project just to define a library for use by such systems.

Every session is relative to a project; you can start a new project from within EiffelStudio by following the menu path:

File --> New Project

Every project has a project directory which will contain the files generated and managed by EiffelStudio. The project directory may also host some of the source files containing your Eiffel classes, the ECF (eiffel configurationl file), and external software written in other languages. However, it is not required that everything be stored together; the source files and ecf may reside anywhere. Some users, in fact, like to put nothing other than the EiffelStudio-generated files in the project directory; this separates user-managed and system-managed files, and can facilitate configuration management, backups and porting.

In this simple Tour, things have been set up so that all the files of interest, source texts as well as generated ones, will appear in the project directory YOURDIR (either $ISE_EIFFEL\examples\studio\tour or the copy that you have made). Go to that project directory using the Windows explorer or a cd command, and look at its contents (using ls on Unix/Linux):

The contents of this YOURDIR directory includes the following:

• First you see a number of files with the extension .e , for "Eiffel": heir.e ,  invalid.e and others. These are the Eiffel source files, each containing one class. The recommended convention is to store a class of name CLASS_NAME into a file of name class_name.e , where class_name is the lower-case version of CLASS_NAME ; here, file heir.e contains the class HEIR and so on. As you may remember, Eiffel is case-insensitive, but the standard convention for class names is to write them in all upper case. Calling the file class_name.e is only a recommendation, not an obligation; but you are required to store one class per file. This keeps things simple and facilitates project and configuration management.
• You also notice a file with an ecf extension. This is the configuration file that specifies this project. As you remember, the ECF file for this example was available as part of the delivery; we used it to compile the project. In most practical cases, however, you won't need to build an ECF; if you use the "Create project" option of EiffelStudio, EiffelStudio will build the ECF for you; if you change the Project Settings during a session, EiffelStudio will update the ECF. ECF files are written in a XML notation.
• You will notice a subdirectory called EIFGENs, for "EIFfel GENerations". EIFGENs is created and maintained by the compiler to store information about your project, including generated code for execution. EiffelStudio manages your project in such a way that EIFGENs can always be re-generated if need be; this means in particular that if things go wrong for any reason and you want to make a fresh start you can always delete this directory and recompile your system. This also means that you should not add any files into this directory, or modify any of its files, since a later compilation is free to change or regenerate whatever it chooses in EIFGENs.
• Because the demonstration system for the Tour is a Microsoft Windows system, there is a file named simple.rc in the folder. This is a Windows resource file that was created automatically by EiffelStudio.

Later on, we will see that EiffelStudio may generate three more subdirectories of the project directory: Diagrams, if you produce graphical system diagrams; Documentation, if you request system documentation, for example HTML; and Metrics, if you perform measurements on your system. Other than these directories, EIFGENs EiffelStudio will not touch anything in the project directory, so you may safely add and change whatever files and subdirectories you like.

You seldom need to look into EIFGENs, although you should know that it's there. Right now if you check the contents of the project directory YOURDIR (using the Windows Explorer on Windows, the ls command on Unix, or some equivalent mechanism), you will see that EIFGENs has been created, itself with a subdirectory called classic which is the name of the target and which has some subdirectories, including W_Code which contains the generated code ( W for "Workbench" -- we'll see the reason later). Feel free to browse through it if you like, but don't change anything.

By the way, we are now done with any platform-specific instructions. Everything in the rest of this Tour, other than the graphical look-and-feel, will work the same across all EiffelStudio platforms.

Starting To Browse

It was important to take a look at how EiffelStudio stores your project, but unless your idea of fun is to poke around directories to look at compiler-generated files that's not really the exciting part yet. Among the most innovative aspects of EiffelStudio is a unique set of facilities to "browse" through a software system.

Browsing style

Browsing -- traversing the structure -- is particularly important in object-oriented development and especially in Eiffel because of the speed at which you can construct sophisticated class structures, making use of inheritance, genericity, the client relation and information hiding, and subjecting features to all kinds of adaptations -- renaming, redefinition, undefinition, effecting -- that are key to the expressive power of the software, but call for smart tools to keep track of what's going on. EiffelStudio's tools are second to none. Among their key properties:

• You can choose many different ways of browsing: sometimes you know the name of a class or feature, and will get to it just by typing it; sometimes you want to traverse the system through its cluster-subcluster structure; often, you see a reference to element (class or feature) in the text of another element, and just want to get to it by following that reference, like a hyperlink. You'll be able to use all these techniques, and alternate freely between them.
• The browsing facilities are always available. There is no "browser" in EiffelStudio; you just browse when you want to, by looking at the information you need. You can do this while editing, debugging, or performing any other of the analysis, design, implementation, extension and maintenance tasks of system construction.
• Although classes are stored in files and clusters in directories, you can for the most part forget about the file system. Unlike most environments, which let you manipulate files containing software texts, EiffelStudio lets you concentrate on your development objects -- the units that make sense for you: features, classes, clusters, systems. You think in terms of those conceptual units, and don't have to worry about where they are stored. Most of the time, you'll just forget about files and directories.
• You can produce many views of the development objects. For a class, you may see the full text, the interface only, the inheritance structure, the clients, the features, and many other views. You can even display graphical views along with textual ones. All these are fully browsable; you can go from one to the other as you please.

A Development Window

Let's see how this works. First, take a look at the EiffelStudio window:

Note: If some parts are too small, just resize the window to arrive at something like what's on the figure. As soon as you have resized it, EiffelStudio will remember that size, and start up in the next session with the size you've set.

You can see that the bulk of the Development Window is divided into three primary panes or areas. The Editing tool is the large pane on the top left. The Editing tool supports a tabbed display of the elements in your system ... usually that's class text, and it's in the Editing tool that you make changes to your software. In the image above, it is targeted to the root cluster of our example system. We'll target the Editing tool to a class in a moment. The other two areas support multiple tools, also using a tabbed display. In the area below the Editing tool you see the Outputs tool currently selected. As you can see there are other tools represented by the tabs at the bottom of the same area. Likewise, the area to the right of the Editing tool shows the Groups tool selected, but in that area are also tabs for other tools. You will find that the layout of the Development Window is very flexible. Different tools can be made visible or hidden, panes can be removed, new panes created, tools can be docked in these areas or viewed as standalone windows. The appearance of EiffelStudio can be tailored to your needs and preferences.

So far we have talked about "the EiffelStudio window", but in fact that's not correct. What you see is one Development Window, of which you can have as many as you wish. Some people prefer to use a single development tool, avoiding screen clutter; others don't think twice about having lots of windows, taking the "desktop metaphor" to its full conclusion (some non-computer desktops are quite cluttered). There are many ways to start a new Development Window; for example if you look at the entries in the File menu at the top left -- don't select any of these entries yet, just look -- you'll see, among others, New window, which would create a new Development Window.

Whether you have one Development Window or many, each may have as its target an element of the system: system, cluster, class (the most common case), feature, run-time object. This simply means that the tool displays information about that element.

Retargeting by name

In our first look at the Development Window, the Editing tool was empty. To target it to a specific class, you can just type the class name -- if you know it -- into the Class field at the top left:

Let's use one of the most basic classes, STRING_32 from the Kernel Library of EiffelBase. Bring the cursor to the Class Field, click to make it active, type string_32 (or STRING_32 ) and the Enter key. As shown on the next figure, this causes a new tab to be created in the Editing tool and retargets the Development Window to class STRING_32. Note that you didn't have to worry about where the class resides in the files of your computer. Also, it doesn't matter, when you enter the name into the field, whether you use lower or upper case, or some mix; EiffelStudio will show the name in all upper case because that is the standard Eiffel convention for class names.

Retargeting by name is only one way to retarget a Development Window. There are other ways of retargeting that are useful at different times. Let's look at some of them.

Retargeting from the Groups tool

Your first browsing action used a class of which you knew the name, STRING. What if you don't know what's in the system and want to explore it? Among other techniques, you can let the Groups tool, guide you through the classes that are available to your system.

An Eiffel system, as you know, is organized into clusters and libraries (and assemblies on some .NET systems). Additionally, clusters can be structured hierarchically into subclusters. You can expand the clusters and libraries nodes in the Groups tool (by clicking the little + signs to the left of the node icons) in order to see the classes. Try it, and what you see should look about like the following figure:

You'll see one cluster: root_cluster, containing the few classes specific to our Guided Tour system. Under libraries you'll see base which provides the classes of the EiffelBase library, and base_precompile which does not provide any classes directly (precompiles are present to speed up compilation time by precompiling classes, so base_precompile is just a precompiled version of the contents of the EiffelBase library). Let's go into base, Eiffel Software's open-source library of fundamental reusable mechanisms.

The most extensive subcluster of the EiffelBase library is structures, which contains implementations of major data structures and algorithms of computing science. Expand structures to see its own subclusters:

Note: If you initially don't see as many details as shown on this figure, you may get them by resizing the window, moving the vertical pane boundary, and/or scrolling.

The EiffelBase Data Structure library and its subclusters are described in the book Reusable Software. Let's go to one of the most frequently used subclusters, list, containing implementations of list structures. Expand the subcluster list. This time, since list is a terminal cluster, it's not subclusters you'll see, but classes, identified by small ellipses ():

The ellipse, or "bubble", is indeed throughout EiffelStudio, as in the Business Object Notation (BON, the underlying graphical convention), the distinctive symbol for classes. You will notice that instead of the bubble, some classes are represented by what we call the "expanded" icon ( ). These are still Eiffel classes. They are represented this way to show that they are marked as expanded. Still other classes have a modified bubble ( ) indicating that they are marked as deferred.

Our second technique for retargeting a Development Window to a class (other than typing the class name as we did before) is to click the class in the Groups tool. Do this now: click LIST in the tree. It doesn't matter whether you click on the class name or the adjacent bubble. This retargets the tool to class LIST.

As the tool is now targeted to LIST, the Class Field at the top left now shows the name of that class, exactly as if we had typed that name, the way we did with STRING_32 in the previous method of retargeting.

Moving back and forth

Here now is a third way to retarget. Towards the top-left part of the Development Window there are Back and Forth buttons, which will enable you to revisit classes already seen during the current session:

Click the Back button. This retargets the tool to the class you visited previously: STRING_32. The Forth button, immediately to the right of Back, becomes active. Click it to retarget back to LIST.

Note that all buttons of the interface have a "tooltip" as shown in the figure above. if you move the cursor on a button, without clicking, and wait a second or so, a small message comes up, explaining the purpose of the button. Also, if there is an associated keyboard shortcut, it will be displayed in the tooltip.

The Target History

As a fourth way to retarget -- there are more, and after this one we'll stop counting -- you can also use the Target History menu, which you can bring up through the little arrow to the right of the Class Field:

If you click this arrow -- the little black triangle -- you will see a menu of all your recent targets. Doing this now will only show the two classes visited so far, STRING_32 and LIST, but later on there will be more entries. By default EiffelStudio remembers 20 history entries; this is one of the settings you can change later if you wish, through the menu path:

Tools --> Preferences

Adding to Favorites

If you find yourself often needing to examine a particular class, you can add it to your Favorites, much like adding an interesting page's web link to the bookmarks of a Web browser.

It's easy to add the current target -- currently, LIST -- to your Favorites. Do it now by following the menu path:

Favorites --> Add to Favorites

Now display the favorites; one way is to go back to that same Favorites menu:

Favorites --> Favorites

This gives us one more way to retarget a Development Window: click a class in the Favorites tool. Two ways actually, because once you add a class to Favorites, it appears in the Favorites menu and you can select it by choosing its menu item.

Right now we don't need the Favorites tool, so you can get rid of it by clicking the little Close icon at the top right of the Favorites pane:

After you close the Favorites tool, you may see some tool other than the Groups tool that we had been using. If this is the case, click on the Groups tool's tab at the bottom of the pane to make the library classes visible again.

Using additional Editing tool tabs

So far, even though we've targeted to the Development Window to different classes, we've only used one Editor tab. But it is helpful sometimes to have views of several classes handy in multiple editor tabs. Its easy enough to create a new tab at the time that you target the Development Window to a new class. For example, you should see the class CHAIN in the Groups tool's view of the the list subcluster of structures (the same place we found class LIST. Instead of clicking on CHAIN the way we did LIST, this time control-right-click on CHAIN, that is to say, click with the rightmost button of the mouse while holding the CONTROL key on the keyboard. This creates a new tab for CHAIN and retargets the Development Window to that class, while sliding the existing tab for class LIST to the right a bit.

You can click on any of the tabs and the Development Window will be retargeted to the class associated with the tab. Each tab has a "Close" button on it, so you can close tabs you no longer need.

So, for now, close the tab with the class CHAIN and leave just the one tab with class LIST.

Using additional Development Windows

With all the techniques seen so far, you were able to retarget the current the Development Window to a new class. And that may be all you'll ever need. But, as noted earlier, you may also wish to have two or more Development Windows active simultaneously.

To create a new Development Window, follow the menu path:

File --> New Window

You can close a Development Window either by clicking its close button in the corner of the window, or by following the menu path:

File --> Close Window

Be careful not to try to use:

 File --> Exit

If, during a session, you end up with a number of windows active and want to see an active index to them, you can invoke the active windows tool by following the menu path:

View--> Tools--> Active windows

Viewing Classes

We haven't really looked at the text of a class yet. It's important anyway to see how EiffelStudio provides you with numerous, complementary views of your software. The Class tool and Feature tool are where the bulk of these views will be displayed, although the Editor tool does support some special views. For now we will concentrate on the views available in the Class tool.

Making some room

We'll need just one development window for the moment, the one that was targeted to LIST. You should still have that window available from the previous Tour topic, and it should look about like this:

Note: If you don't see a development window targeted to LIST, just retarget one, as you know how to do this now, for example by typing the name followed by Enter in the Class Field at the top left.

First let's give ourselves more space. Right now we don't need the Groups tool or any of the other tools sharing that pane. We could get rid of them by clicking the close buttons on the top right corner of the panes. Then we could get them back later by following the menu path:

View --> Tools --> x

We do this by setting the pane containing the tools to Auto Hide. On the bar at the top of the pane, you'll see the Auto Hide icon () which looks like a pushpin.

Click the icon and you'll see the pane shrink into a set of tabs on the right window margin and the remaining panes will expand to fill the abandoned space. The tools in the pane will temporarily expand back out if you move your mouse cursor over their tabs. Try it with one. When you want the pane back in its original place permanently, you just expand one of the tabs by mousing over it, then click the Disable Auto Hide icon, which is the pushpin again, just horizontal this time.

Two panes remain, showing the Editor tool and the lower pane containing the Outputs tool and others. You can resize the panes by dragging the border between them. Make sure there's plenty of room in the lower pane.

The Class tool

Before we look at the Class tool, let's make sure that we set linked data share mode which will always display information about the current target. Go to the main menu bar and expand the menu item View. If you see a choice marked with the link context icon () and labeled Link Context Tool, then select it. After it has been selected, or if it has already been selected, then the label will read: Unlink Context Tool.

At the bottom of the lower pane you'll find a tab labeled Class. This gives you access to many forms of information about the current class -- the target of the development window. Click on the Class tab to bring up the Class tool. A set of buttons at the top enables you to display a number of views of the class. The currently highlighted button indicates the default view: Ancestors. You can see the others' names by moving your cursor over the various view icons, and reading the tooltips.

The view currently displayed, Ancestors, shows the inheritance structure that leads to the current target, LIST :

This shows that LIST is an heir of CHAIN which itself, as an example of multiple inheritance, is an heir of CURSOR_STRUCTURE, INDEXABLE, and -- twice, as an example of repeated inheritance -- SEQUENCE. If, because of direct or indirect repeated inheritance, a class appears more than once, the display doesn't repeat its ancestry the second and subsequent times; the omitted repetition appears as just three dots, ..., as illustrated here for the second occurrences of BAG, ACTIVE and others.

As you may have guessed, all the class names that appear on this display, by default in blue, can function as hyperlinks: you can use any one of them to retarget the Development Window to the corresponding class. This will be another major retargeting mechanism. But let's not pursue it for the moment and instead continue looking at the documentation views.

Next to Ancestors button is Descendants, which will give you the descendants of a class in a similar format:

The progeny of LIST, as you can see, is just as impressive as its ancestry.

Let's now look at the other formats, starting from the left. The first button, Clickable, gives the class text. It's essentially the same information as appears in the top Editing Tool (whose pane was reduced to its bare minimum in the last few pictures, showing only the first three lines or so), but with some differences:

• The Text view in the Editor is editable. In fact it's EiffelStudio's primary tool for entering software texts. The Class tool's Clickable view is just a view; you can't change it.
• The Text view retains the formatting of the class text the way it was typed in; the Clickable view is automatically formatted -- "pretty-printed" -- according to the standard Eiffel layout rules.
• The Clickable view does not include comments inside routine implementations ( do and once clauses), although it does retain features' header comments.
• As part of the pretty-printing, the Clickable view uses colors and fonts to distinguish keywords, identifiers, comments and other syntactical elements. You can change the fonts and colors, like many other elements of the interface, through Tools --> Preferences. (Now is not the time.)

This view is called "Clickable" because, as we'll see later, every syntactical element on it is a hyperlink, which you can use for browsing.

After Clickable comes the Flat view button. The layout of the result is similar. The flat form of a class is the reconstructed class text including not only what's declared in the class itself but also everything that it inherits from its ancestors, direct or indirect. This applies to the flat form's features, which include ancestor features, but also to contracts: the flat form's invariant includes all clauses from ancestors' invariants, and the preconditions are expanded to take require else and ensure then clauses into consideration. (The Eiffel Tutorial explains these notions in detail.)

As a result, the Flat view shows the class text as it might have come out had inheritance (what a horrible thought even to contemplate!) not been available to write it.

The first two features appearing in the above display, cursor and first, are indeed inherited from ancestors, rather than declared in LIST itself. Note how EiffelStudio, when producing the flat form, adds a line of the form

            -- (from CLASS_OF_ORIGIN)

to the header comments of inherited routines, to document where they come from.

The flat form is an important notion of object technology, making it possible to understand a class by itself, regardless of the possibly rich inheritance structure that led to it. Looking at the Flat view of LIST, you may note how few of its properties come from the class itself; most of the interesting work has been done in ancestors, and LIST just adds a few details.

Note: If at any time you want to search for a certain pattern in the views displayed, you can type CTRL-F. A Find bar will come up at the bottom of the pane you are using. If you need more searching power, click the Search icon () in the development window's tool bar to invoke EiffelStudio's Search tool.

Next come two essential documentation views: Contract and Interface. Based on Eiffel's principles of Design by Contract, they document the interface properties of a class. Unlike the previous two, they do not show actual Eiffel texts, but information useful for client classes.

The contract form (also known as the short form of a class) is the class text deprived of any internal detail to retain interface information only. It discards any feature that's not exported (available to all clients); for the retained features, it discards the implementation -- do or once clause -- but retains the header (feature name, arguments, results), the header comment, and the contracts (precondition, postcondition, invariant) minus any contract clause that refers to a non-exported feature and hence would be useless to clients.

As you will know, particularly if you have read the book Object-Oriented Software Construction, 2nd Edition, the contract form is the preferred way of documenting software elements, especially reusable components, as it provides clients with just the right level of abstraction: precise enough thanks to the type signature and the contracts; clear enough thanks to the header comments; and general enough since it omits implementation details that are irrelevant to client programmers (and might lead them to write client code that won't work any more if the implementation changes).

In practice you will often want to use, instead of the Contract view, the next one, Interface, also known as "flat-short form" and "flat contract form", which applies the same rules to the flat form rather than to the original class. This means it shows information on all the features of the class, immediate (defined in the class itself) as well as inherited, whereas the short form, non-flat, only considers immediate features. The Interface view provides the complete interface information for the class. Try it now on class LIST.

The next two buttons are for the Ancestors and Descendants views, which we have already seen, showing classes connected with the target through one of the two inter-class relations, inheritance. After them come Clients and Suppliers, to list the classes connected through the other relation, client. Clicking the Clients button shows the list of clients of LIST.

Now click the next button to see the Suppliers of LIST.

The only two classes that LIST needs for its own algorithms are basic types from the Kernel Library, BOOLEAN and INTEGER_32. In Eiffel, as you may remember, all types are defined by classes, even those describing such elementary values as integers and booleans.

Feature information in the Class View

Let's resist the natural urge to go see now what the classes INTEGER_32 and BOOLEAN look like, and instead continue our survey of views. The remaining views will all display information about the features of the class. The first of them, Attributes, lists the attributes. It's not very interesting for LIST, a deferred class with only one attribute -- you can check this for yourself by clicking the Attributes button -- so let's look at the next one. Click the Routines button now to display information about the routines of class LIST :

The sections of this display group routines according to the ancestors of LIST -- including LIST itself -- that first introduced them; for example append originally comes from CHAIN and back from BILINEAR. Much of the benefit of this display comes from its support for browsing: all the colored elements, representing classes and features, will be "clickable" hyperlinks.

The Invariants button shows the complete class invariant for LIST. This includes all invariant clauses that have been inherited from all ancestors.

Other Class tool buttons display information in the same format as Attributes and Routines. Each selects a specific subset of the target class's features. You can now try any of the others by clicking the corresponding button:

• Deferred features: abstract features which don't have an implementation in the current class, only in eventual descendants. Try this for LIST ; you'll see that this deferred class indeed has a number of deferred features.
• Once and constants: constant attributes, "once functions" which provide shared objects (close to the "singleton" pattern), and once procedures which provide a convenient initialization mechanism. LIST has 'Operating_environment' and 'Io' inherited from the parent class ANY.
• External features, implemented as calls to routines, macros or other elements implemented in other languages. LIST hasn't any.
• Exported features: those available to all clients. LIST has quite a few.

Restoring the look of the development window

Once you're done looking at the different views, let's undo the changes that we made to the configuration of the development window at the beginning of this section in Making some room.

Reduce the relative size of the lower pane.

Then go to one of the tabs on the right margin of the development window, Groups, will work. Hold your cursor over it for a moment and it should expand. Then click the Disable Auto Hide icon, the horizontal pushpin, to restore the rightmost pane.

Customizing the tools layout and toolbars

Overview

We saw in Viewing Classes how EiffelStudio panes could be resized and how the Auto Hide feature works for a pane.

Now let's look at some other ways in which you can customize the layout the EiffelStudio tools.

EiffelStudio uses a default tools layout that generally reflects the preferences of a majority of users. So if you don't change anything in the way that the EiffelStudio interface is originally set up, you should still be able to work well enough. Also, be aware that as new versions of EiffelStudio emerge, it is possible that the layout that "generally reflects the preferences of a majority of users" may change. So, don't be too surprised if things look just a little different after installing a new version.

After considerable experience using EiffelStudio, you may decide that certain changes to the default make sense for the way that you work. For example, you may always want to have certain tools visible which were not visible by default. Once you make a change like this, EiffelStudio generally remembers that change and it will be in force the next time you open EiffelStudio. But you can also save a complete tools layout and recall it at a later time. For example, you might have two or three different development modes that you work in, and have a saved tools layout for each.

The ways in which the EiffelStudio tools can be arranged are nearly endless. You can make tools visible or hide them. You can make almost any tool a tab in almost any pane. You can re-order the tabs for a pane. You can pull tools completely out of EiffelStudio as free-floating windows. You can create additional panes as needed. Almost any pane can be "pinned" open or "auto hidden".

Reverting to the default layout

In view of this, it seems fitting that the first item that we should cover is how to revert back to the default layout in the case in which you get the tool layout in such a state that you just want dismiss the changes that you made and start over.

You can use the menu path:

View --> Tools Layout --> Reset Tools Layout

Figure 1

So at the end of the section Viewing Classes we manually reversed the changes that we had made to the layout to make additional space. We could have just selected Reset Tools Layout to restore the default layout.

You can try this now and see the effect. Your tools layout will probably not change very much.

You can see in the image above that you would also follow that menu path in order to save a tools layout or to activate one that you had previously saved.

Minimizing, maximizing, restoring, and closing tools

At the right end of the top bar for each tool you will see buttons that help you control the way the tool and its containing pane are displayed. Here are the icons and what they mean:

• Minimize this pane.
• Maximize this pane.
• Restore this pane to its previous size.
• Set this pane to Auto Hide.
• Close this tool.

There are a few subtleties you should understand when using these:

The pane in which the Editing tool resides is special. It is the only pane that supports minimize. And it does not support Auto Hide, nor Close. We'll learn a little more about this in the section on Docking.

When you maximize a pane it fills all available space. At the same time, its maximize icon changes to the Restore icon. When you click Restore, the pane relinquishes the extra space it annexed when you maximized it, and then returns to its original size and location.

The Close button will close only the current tool. So, that tool goes away, but any other tools in the same pane remain. However, when you close the last tool in a pane, the pane itself disappears and the space is absorbed by other panes. Remember that you can re-display closed tools through the menu path:

View --> Tools --> tool name

Note: EiffelStudio supports a number of key shortcuts (sometimes called accelerators, some of which can be useful for changing aspects of the Development Window. For example, CTRL+M will toggle the Editing pane between Maximize and Restore, and CTRL+N will create a fresh Development Window. Keyboard shortcuts themselves are tailorable in the EiffelStudio Preferences.

Re-ordering tabs

Within a particular pane, it is possible to have many tools visible. Each will be represented as a tab at the bottom of the pane. For example, the pane that contains the Class and Feature tools has the following tabs by default in the version that is current at the time of this writing:

Figure 2

One easy way to customize your tool layout is to change the order of these tabs if you prefer. Just drag a tab horizontally to a new position to the right or left of where it originally was located and release it. As you drag the tab, you'll see it relocate itself, so you'll know just were it will end up when you release it.

So suppose that you felt that it would be more convenient to your style of work to have the Outputs tool be the left most tool, versus the Class tool. Just drag it over there ... and now your tabs should reflect the new order:

Figure 3

Try this now, if you'd like but be careful to move the tab only horizontally along the row of other tabs. If you move it off the row of tabs, you may inadvertently enter the extraordinary, but more complex realm of docking, our next topic. Just in case you do get off the row of tabs and you see strange icons appearing on the Development Window, don't release the mouse button, just press the ESC key to cancel the dragging action.

Docking

The docking ability within EiffelStudio is arguably the most powerful tool at your disposal for tailoring the tools layout to your liking. Docking can be a little daunting at first, but once you understand a few concepts, you will likely find it both easy to use and helpful.

Maybe the first thing to know about docking is that EiffelStudio gives you the option of locking elements of the interface against inadvertent changes in docking. Following the menu path:

View --> Docking Lock

Perhaps the second thing to understand, if you haven't already guessed, is that, for docking purposes, the EiffelStudio interface supports toolbars and two different types of panes. One type of pane is the one in which the Editing tools reside, which we'll call an editing pane. The other is the type of pane is the tools pane where other tools can be docked.

So, with this in mind, we can take another look at the EiffelStudio layout.

Figure 4

Here we see the editing pane with one editing tool targeted to the class LIST.

There are two tools panes. Docked in one are the Class, Feature, Outputs, and Error List tools. In the other are the Groups, Features, and AutoTest tools ... and to the right of the AutoTest tab we see the icon () and a number indicating that there are more tabs, but no room to display them. In this case there is only one more tab; it is for the Favorites tool. Of course, if the that tools pane were a little wider, we would see the tab for the Favorites tool and the "continued" icon and the number would disappear.

It turns out that there are actually two more tools panes in this layout. One contains the Diagrams tool and the other contains the Dependency, Metrics, and Info tools. These two panes are Auto Hidden so we only see the minimum evidence that they exist ... just their tabs. You can tell that these are two different panes by how the tabs are distributed. Diagram is somewhat "off by itself" whereas Dependency, Metrics and Info are grouped closely together.

As we learned in Viewing Classes you can make one of these tool panes visible by moving your cursor over it, or clicking on one its tabs. The pane will expose itself for the length of time that the cursor remains over it, then recede into hiding again when the cursor is moved away.

Try this now with the Diagram tool. The pane housing the diagram tool appears from the bottom of the screen. Notice also that it has occluded the pane containing Class, Feature, Outputs, and Error List tools, and about half of the pane containing the Groups, Features, AutoTest, and Favorites tools.

Figure 5

So, Auto Hide works well to keep panes that we might not use very often out of the way ... but still pretty handy.

Floating a pane

Let's dive into our first docking (or maybe undocking) experience. Suppose, though, that you were in the analysis and design phase of a project and you wanted the Diagram tool to be open and available at all times. Of course, you could move your cursor over it to "un-hide" it, then pin it open. But then it would be covering the other tool panes which we use often.

One great capability of the docking mechanisms in EiffelStudio is that you can disconnect, or float, a pane away from the rest of the EiffelStudio development window. Let's float the hidden pane that now contains just the Diagram tool out to the right of the entire Development Window.

In order to float this tool pane, we first have to set Auto Hide off.

Note: In versions of EiffelStudio starting with version 6.6, it will no longer be necessary to set Auto Hide off before moving a pane.

So move your cursor over the Diagram tab and the pane should expand (if it does not make it self visible, then click on the tab). Then move to the upper right and click the horizontal pushpin icon () to turn off Auto Hide and pin the pane open.

Figure 6

You may notice that a pane that is auto hidden may, when it expands, occlude other panes. However, when you turn of Auto Hide by pinning the pane open, any panes that it had occluded will become at least minimally visible. In the case of this example, the pane containing the Class tool was temporarily covered by the expanded Diagram pane, as was the row of tabs on the pane containing Groups. When you pin the Diagram pane open, the title bar for the pane with the Class tool becomes visible, and the pane with the Groups tool gets shortened to fit above the Diagram tool's pane.

It is at this point that new EiffelStudio sometimes have problems understanding what's happening. So read the following description of what's going on before you actually try to move the pane ... and don't forget that you can always reset the tools layout if things don't go the way you intended.

Now that we've turned off Auto Hide for Diagram's pane, we can move the pane and either re-dock it somewhere else in the development window or, as is our intention, "float" it as a window separate from the Development Window.

To undock and re-dock or float a pane, you drag the pane by its title bar (but don't do this quite yet). As soon as you begin to drag the pane, you will see the look of the Development window change:

Figure 7

In the figure you can see the cursor arrow on the title bar of the pane. The pane has been dragged very slightly and EiffelStudio has sensed that we want to move the pane from its current position. In response, EiffelStudio has overlaid the Development Window with a set of icons that represent valid docking targets for the pane being moved. We'll look closer at those in a moment.

But for now, notice the large dark, semi-transparent docking feedback area at the bottom left of the image above. This represents what will happen to your pane if you release the mouse button at the current time. So in the case of the figure above, releasing the mouse button immediately will float the pane on top of the Development Window. This is nearly our intent, although we want to move the floating pane out to the right of the Development Window. So, without releasing we drag the pane off the top and to the right of the Development Window, then release it.

Figure 8

So go ahead and try it now. If you've pinned the pane with the Diagram tool open, then drag the pane by its title bar out to the right and off the Development Window and release it.

Docking a pane

The problem that some users have when first trying to adjust the tool layout using docking (without the benefit of this Guided Tour) is that once they move a pane, it's not obvious to them what to do next to get the effect that they want. As a consequence, they attempt to put things back the way that they were when they first dragged the pane ... and usually they aren't successful. Remember that you can always press the ESC key to cancel the drag while still holding the mouse button down.

Now let's take a look at the target graphics and what they mean, and we'll do an exercise in which we put the pane with the Diagram tool back where it was originally.

In Figure 7 above, you can see the docking target graphics. You see this figure:

Figure 9

in two places, and four smaller figures:

Figure 10

one near each border of the Development Window.

The graphic in Figure 9, shaped like a "plus" sign or cross, will appear in any pane which is a valid docking target for the pane you are moving. So, in Figure 7, those panes are the pane housing the Groups tool and the one housing the Class tool.

The center of the graphic represents the target pane itself. So, if you drag your pane over the center of the graphic and release it, your pane will now become a new tab in the target pane. You can see the docking feedback area hinting to this effect. In the figure below, the pane with the Diagram tool was dragged over the center of the target graphic on the tool with the Class pane. Notice that the whole pane is covered with the docking feedback area, which even shows the hint of a new tab.

Figure 11

If we were to release the pane at this point, it would dock as a new tab along side Class, Feature, Outputs, and Error List. In this case, the pane we are moving contains only one tool, Diagram, but if it contained multiple tools, each of those tools would become a new tab in the target pane.

But remember that our goal in this exercise is to restore the pane holding the Diagram tool back to its original position. So, making it a tab in the pane with Class, won't achieve that goal. Let's look at some other possibilities.

What happens if we drag our pane over one of the tips of the cross shaped target graphic? These targets will allow us to split the target pane into two panes, one containing the original content and the other containing the content of the pane we are moving. The original pane will be split according to which tip of the cross you drop your pane onto. For example dropping on the right tip will split the target pane into left and right panes an put your pane on the right. Again you can see this depicted in a preview when you hover over one of these, as shown below.

Figure 12

It's pretty obvious that this will not get Diagram back to its original location. The only options left unexplained are the four graphics shown in Figure 10. These each look like a detached version of one of the tips of the cross shaped graphic, but they are located along the four edges of the Development Window. If you drop your pane on one of these it will add it as a new pane along the corresponding margin of the Development Window.

We know that originally our pane with Diagram was in Auto Hide mode at the bottom of the Development Window.

So, drag the pane from its floating position and drop it at the bottom of the Development window on this graphic:

The effect is that now your pane has been docked back into the Development Window at the bottom. The only thing left to do now is turn Auto Hide back on by clicking the push-pin icon. Now the pane that houses the Diagram tool is back in its original place in the layout.

Docking and the Editing pane

As we learned earlier in Minimizing, maximizing, restoring, and closing tools, the pane in which the Editing tools reside has special properties and restrictions not present for panes housing other tools. It's the same for docking. Just as you can't close the Editing pane, you can't re-dock it in any other location. You can't dock other tools, the Feature tool for example, in the Editing pane (notice that you don't get a targeting cross in the Editing pane when you drag a pane).

Although the Editing pane can house only Editing tools, you can re-order the tabs for Editing tools and you can re-dock Editing tools by splitting the Editing pane. For example you might want to look at two classes side by side in two different panes. In the image below, after opening tabs for classes LIST and CHAIN, we dragged the tab for CHAIN and dropped over the right tip of the cross shaped graphic that appeared in the Editing pane. Then we put the pane Groups and the one with Class in Auto Hide to enlarge the size of the Editing tools. This allows us to view LIST and CHAIN side by side.

Figure 13

Docking and toolbars

You can drag toolbars and re-dock them in different places. You can float toolbars in the same way you would do a tool pane. In the figure below, the Project toolbar has been dragged away from its default home to the right of the Standard Buttons toolbar. Now it's over undockable space, so if released here it will float, just as we saw with tool panes.

Figure 14

When you move a toolbar, drag it by its "head". The head is indicated by an icon () that looks like a vertical row of dots at the left end of each toolbar.

The figure above shows that there are two "rows" available for placing toolbars. This is the way it is in the default layout. But the number of rows can be expanded if needed. So, if you drag a toolbar toward the bottom of the toolbar area, you will see that a new row will become available in which you can dock the toolbar that you are moving.

Figure 15

In the figure above, the Project toolbar has been dragged near the bottom of the toolbar area, and a new toolbar row has opened up to allow the Project toolbar to be docked there.

Customizing toolbars

In addition to using the docking facilities to move toolbars around to suit your work style, you can also customize each toolbar by adding, removing, or re-ordering the buttons on that toolbar. See more about this on the page Toolbar customization.

Producing and Exporting Documentation

Software development is, most of the time, cooperative work. You must tell the rest of the team what you're up to, and find out what they can offer you. Bring in distributed development -- increasingly common these days, with some people working at headquarters, others at home, others traveling, an offshore team half a world away ... -- and the problem becomes even more critical.

EiffelStudio provides unique facilities to make such distributed development possible in a safe, effective, harmonious way. Some of the key criteria are:

• You must be able to export the information easily to the World-Wide Web, the most general and widely available interaction mechanism.
• The documentation must be faithful to the software. Because of the ever-changing nature of software, this goal is impossible to satisfy unless the documentation is extracted from the software -- as opposed to the traditional approach, still perpetuated by many CASE tools, of treating the two as separate.
• The task of updating the documentation after a software change must be straightforward and automatic.
• It's not enough to support HTML; many other formats are useful too.
• Users must have the ability to adapt the mechanism to support new formats.
• For existing formats, they must have a way to tune the output easily to any specific style standards, company policies, local variants.

EiffelStudio's documentation generation satisfies all these requirements.

Documentation filters

Let's see how documentation works by starting to generate it for our Guided Tour system -- which really means for EiffelBase, since that's what it mostly consists of. The HTML result is available as part of the present documentation (we'll tell you where in just a minute), so you don't have to regenerate it unless you want to. Indeed we'll show you when to click Cancel if you are happy with the pre-generated version. But let's get started anyway to understand the principles and possibilities.

Click the following menu entry, used to generate documentation:

	Project --> Generate documentation...

This is the next-to-last entry in the Project menu. The last one, by the way, XMI Export ..., is directly relevant too: it will make it possible to export information in the standard XML representation for UML, for consumption by third-party products such as Rational Rose. But for the moment we choose the Documentation entry to start the Eiffel Documentation Wizard.

The Wizard starts with a list of available output formats, also called filters:

The filter names correspond to major documentation formats which EiffelStudio supports by default. Among the most important, listed here in rough order of appearance in the list:

• ASCII : plain text, no formatting codes.
• eiffel : essentially the same as ASCII; useful if you want EiffelStudio to pretty-print your class texts and replace the originals, as explained below.
• MML : internal format for Adobe FrameMaker.
• Postscript : to generate Adobe Postscript output, suitable for printing on a Postscript printer, display on a Postscript previewer such as Ghostscript, or distilling to Adobe PDF.
• COM : to generate class specifications in the form of an Interface Description Language (IDL) interface for Microsoft's COM component model.
• RTF : Microsoft's Rich Text Format, used in particular for Windows "Help" files.
• TeX1, TeX2 : two variants for Donald Knuth's TEX processing format.
• troff : if you already know what this is, congratulations (or condolences), you've been around the industry for a while. This is a traditional text-processing format available on Unix systems. Also works for the gtroff variant.
• html-classic : HTML, no style sheets. The next variant, with style sheets, is strongly recommended unless your colleagues will be reading your documentation with Mosaic 1, vintage 1993, or Netscape 2, Vintage 1995.
• html-stylesheet : HTML with style sheets. This is particularly attractive for Web publishing not only because the output makes full use of style sheet capabilities (fonts, colors, layout, formatting) but also because it becomes trivial to change the look-and-feel to support any style you or your users like, even after generation, simply by editing the style sheet file.

Not only do these predefined filters provide support for a number of important industry formats; better yet, if you want another format not represented on the list, or would like to adapt an existing format to your own style preferences, it's easy to define a new filter. The list that EiffelStudio displays comes from the files with a .fil extension that it finds in a subdirectory of the installation: $ISE_EIFFEL/studio/filters

To define a new filter, simply add a file to this directory. Filters are expressed in a simple notation called EFF ( Eiffel Filter Format ), general enough to support a wide variety of tools for text processing, project management, Web publishing etc. The best way to define a new filter is usually to start from an existing one and adapt it. You will find the specification of EFF at the end of this manual, here .

Generating an HTML record of your project

Let's select the most obviously attractive of the predefined filters: HTML with stylesheets. Click the line html-stylesheet in the list to make it active, then click Next at the bottom of the Documentation Wizard window. The next window appears:

In this pane you select which parts of your system you want to be included in the documentation. By default, all library and cluster names are checked. You should uncheck any that you do not want included.

Note that each library or cluster name must be checked or unchecked individually. For example, unchecking "base" will not automatically deselect "elks" and "ise" which appear under "base".

For this Tour we'll want to generate everything, including EiffelBase, so make sure that in the end all library and cluster names are checked, as in the figure. Then click Next.

Generating Metatags from Note entries

The next step of the documentation wizard asks you to select Note entries:

Eiffel classes, as you know, may start with an note entry that enables class authors to include documentary information in any category they like. It is standard (and part of the official style guidelines) to include at the very least an entry of the form description: Descriptive text in every class. The earlier displays of class LIST showed that entry, which read " Sequential lists, without commitment to a particular representation".

You may have noted that the purpose of Eiffel's note clauses is, conceptually, similar to that of metatags in HTML. Metatags carry information which Web page visitors do not normally see in the browser; this information is available, however, to search engines and other tools that explore and classify Web pages. So it seems quite appropriate to generate metatags from note entries.

The dialog illustrated in the last figure lets you select the entries you wish to transform into metatags. It appears only if you have selected an HTML filter. It lists all the note tags found anywhere in the system; those that are checked will be retained for metatags. Initially unchecked are three tags ("date", "revision", and "status") conventionally used -- at Eiffel Software and other Eiffel sites -- for interfacing with configuration management tools, and hence of internal interest only.

There is no need to change the default selection, so just click Next.

Choosing a level of detail

The next step of the Documentation Wizard lets you specify what kinds of documents you want to generate:

This is a very important facility since it gives you control over how much you want to publish about the properties of the software:

• You may want to publish everything, source included, for example on your Intranet for a group of developers working closely together on the same classes, or on the Internet for open-source software.
• You may want to publish only the interfaces (Contract or Flat-Contract views). This is not necessarily to protect proprietary information; even if you don't care about showing your source code, it is usually too detailed for client programmers, especially in the case of libraries. If various teams work on separate parts of a project, what each releases to the other should usually be the specification, not the implementation.
• You may of course want to publish both the text and the interface, and let the recipients use the version that best suits their needs for each use.
• You may want to publish the diagrams, showing the structure in graphical form. Note the warning -- which we are about to ignore -- telling us this may take a while.
• The class list, cluster list, cluster hierarchy view, cluster chart (following the conventions of BON) are also optional.

The dialog shown on the last figure lets you specify the exact combination you wish. The figure indicates the default options.

This time, if we generate anything, we'll generate everything. Please check all the boxes (the generation won't occur until the last step) and click Next to move to the next dialog of the Documentation Wizard.

Specifying cluster views

The next dialog only appears when you have asked to generate diagrams:

Although we didn't use this possibility yet, the Diagram view lets you define different subviews of any cluster. One view might show inheritance only, the other client links only; one might include all classes, the other hide some library classes. The last dialog shown will allow you, for any cluster, to select a subview other than the default for the generated diagram.

Here we only have the default view, so just click Next.

Generating

The last dialog simply asks you where you want to generate the result:

By default, as shown, EiffelStudio will produce the documentation in a subdirectory -- created for the occasion, if it doesn't exist yet -- of the project directory:

.../your_project_directory/Documentation

You may, however, select any other location you like. In the case of HTML generation, as here, EiffelStudio takes great care to use only relative hyperlinks so that you can move the Documentation directory around, for use either on a file system or on your Web site, with the guarantee that the hyperlinks will work -- as long as you move the entire directory together.

To continue the Guided Tour, you do not need to complete the generation now unless you want to. If you are happy to continue without generating the documentation at the moment then click Cancel on the last dialog.

Note: If you do prefer to produce your own local version of the full documentation for the guided tour system, click "Finish". The process takes 7 minutes on the Thinkpad configuration mentioned earlier, and generates a documentation directory of about 220 megabytes.

Browsing generated documentation

Let's take a look at the generated documentation. We start with the root of the generated documentation, Documentation/index.html :

This root page shows overall information about the system. The top set of links, repeated at the bottom, enables you to browse the system from its list of classes, its list of clusters, or the cluster hierarchy; note the box labeled to Go, which provides a built-in search engine, enabling you to type any class list and go directly to the corresponding page. Let's look at the class list: click the box Classes at the top left.

This shows the beginning of the list of classes, alphabetically sorted. You could click any class to get the corresponding information, but wait; we'll look at individual classes in a moment. Instead, click Cluster hierarchy to see the overall organization of the system into clusters:

Click BASE to see details of the EiffelBase library where (under EiffelStudio) we had found the class LIST used as example in the preceding sections:

This indicates the relations of the cluster to others in the hierarchy, and its list of classes. Again you could click any class name but instead note the link (diagram) next to the cluster name near the top. Remember that when generating the documentation we elected to generate everything, diagrams included. Hadn't we checked the corresponding check box, the (diagram) link wouldn't be there. Click it now to get the diagram that has been generated for BASE:

The output is a diagram showing graphically the classes of the cluster and their inheritance relations. All EiffelStudio-generated HTML diagrams use the PNG graphics format ( Portable Network Graphics ), supported by all recent browsers.

The class bubbles in a diagram are all hyperlinks. To see the HTML documentation for our old friend the class LIST you could just click its bubble. But because this diagram includes the whole library and is automatically generated, you'd have to look around a bit for the LIST bubble. Go ahead and do that if you wish, or just type the class name LIST into the Go to field and press return:

The display shows key information on the class, in a form called the "Chart format" listing the ancestors and then the features, divided into Queries (shown in part on the figure) and Commands. Note that all class names and feature names are hyperlinks, which would lead you to the appropriate place in a class text.

The top row of hyperlinks now includes class formats corresponding to those we discovered in Viewing Classes in EiffelStudio: Relations (covering ancestors, descendants, clients, suppliers, ), full Text, Contracts, Flat contracts. Click Flat contracts to see the full interface of the class:

We'll stop this brief review here but you may continue browsing through the HTML pages if you like. Note how closely the appearance of the class texts, flat forms, contract forms, diagrams and other forms of documentation matches the corresponding formats under EiffelStudio.

Although we suggest staying with the standard, you can easily change any convention that doesn't match your own preferences:

• For the EiffelStudio appearance, use Tools --> Preferences.
• For the HTML appearance, if you know about Cascading Style Sheets (CSS) for HTML, edit the style sheet default.css. You will find this file in the generated documentation directory; alternatively, to ensure the changes are applicable to the generated documentation of all future projects, edit defaults.css in the directory after backing it up. For more profound changes in the structure of the generated HTML, you may also backup and edit the Eiffel Filter Format file html-stylesheet.fil in the same directory. EFF is described in the Appendix .

	$ISE_EIFFEL/studio/filters

The documentation generation mechanisms, using HTML or other formats, let you publish your designs, at the level of detail you desire, on an Intranet, the Internet, or as part of documents you release. They are an important part of the power of EiffelStudio for quality software development.

Browsing Features

Let us get back to EiffelStudio. Before studying the documentation generation we saw how to display properties of classes. It's also interesting to explore the properties of features.

There are two tools with similar sounding names that we will use to explore features:

1. The Features tool (plural) which provides a list of the immediate features of the class on which the development window is targeted. This tool is located by default in the vertical pane on the right hand side of the development window.
2. The Feature tool (singular) which allows you to explore the properties of some particular feature. By default, the Feature tool is available as a tab on the lower pane of the development window along with the Class tool, Outputs tool, and others.

Your Development Window should still be targeted to class LIST, from the last view, Routines, that you displayed on it. If you've lost it, just retarget a Development Window to this class.

Let's start by making the Features tool visible. To see the Features tool click on the tab labeled (note that this is the plural "Features" versus the singular "Feature").

If the tab for the Features tool is not visible, bring it back by following the menu path:

View --> Tools --> Features

While we are at it, let's get make the Feature tool visible as well. Click on the tab on the lower pane that's labeled . As with the Features tool, if the Feature tab is missing, you can use the menu path to restore it.

One more thing, and we'll look at some features. If you restarted EiffelStudio since you worked through the Viewing Classes section, you may have to select Link Context Tool again from the View menu.

Targeting to a feature

The list of features, organized by feature clauses, appears in the Features tool:

The class only has a few immediate features because most of its interesting features are inherited. Make sure the Editor tool is tall enough (as on the above figure) and click the feature forth, the last one, in the Feature Tree on the left. This makes the feature the Editor tool's current target, and scrolls the text to its declaration:

Note how both of the top target fields are now filled: the first one shows the target class, LIST, and the second one shows the target feature, forth.

Basic feature information

Now let's look at the views of the feature forth provided in the Feature tool.

A view of forth is already visible in the Feature tool. By default, it is the Flat view.

The flat view of a feature, similar in concept to the flat view of a class, gives the full text of a feature, taking into account any inherited precondition or postcondition clauses. Here the feature as declared in the class appears in the top Editing Tool, with no precondition and an ensure then postcondition clause. But it's a redefinition of an inherited feature; the flat view in the bottom Context Tool shows the full precondition, inherited from the ancestor LINEAR, as well as the postcondition from LIST.

Flat is just one of the available Feature Views, shown by the buttons on the toolbar of the Feature tool.

You can mouse-over the different buttons to see the views they represent.

Just to the left of Flat, Basic Text gives the feature text, fully clickable.

Who calls this feature?

To the right of Flat is Callers. Try it now by clicking the corresponding button. You may have to scroll down some in the display to see the series of entries show in the image below;

This view shows all the places in the system that call the routine, or one of its redefinitions. Such information can be invaluable for debugging in particular. The successive paragraphs correspond to the various versions of forth in class LIST, its ancestors and its descendants. Reading from the top we'll examine a few entries:

• The version from LIST is called in LIST itself by the function is_equal.
• The version from LIST is called in routines in two debugger classes RT_DBG_CALL_RECORD and RT_DBG_COMMON
• The version forth from MULTI_ARRAY_LIST is a version in a descendant of LIST, and is called by three routines of MULTI_ARRAY_LIST itself: duplicate, put_right, and remove_right.
• Although it is not shown in the figure, if you scroll around some, you will find cases in which a descendant of forth has been renamed and that renamed version is called. For example child_forth from LINKED_TREE is descendant version of forth and is called by routines in LINKED_CURSOR_TREE and LINKED_TREE.

The following five view buttons are similar except that they let you specify what kind of callers you are looking for, or what is being called by the currently selected feature. Feel free to explore these views.

What happens to my feature through the inheritance hierarchy?

After the caller/callee views, the next view button is Implementers.

This is a very useful view, showing all the ancestors and descendants of LIST that provide a separate version of forth, including the original introduction of this feature in LINEAR and subsequent redeclarations (redefinitions or effectings). The mention (version from) signals the version applicable to the current class, here LIST.

Since all class and feature names on these views are hyperlinks, you can display any of the listed versions in a new Development Window by control-right-clicking it (we will see shortly how to display it in the same tool). Right-click on the feature name forth on the line that reads MULTI_ARRAY_LIST forth. This brings up a context menu and chose Show --> Text. The tool is now targeted to the routine forth from MULTI_ARRAY_LIST, so that you can see the implementation of the routine in that class.

We still have two unexplored views, Ancestor versions and Descendant versions. Click the first of these to obtain the ancestor versions of forth from MULTI_ARRAY_LIST.

The format is self-explanatory: for each ancestor of MULTI_ARRAY_LIST that has a version of MULTI_ARRAY_LIST 's forth feature, it indicates the name of that feature -- which could be something else than forth as a result of renaming, although here this happens only in descendants, not ancestors -- and the version of the feature applicable to the given class.

In the case of feature merging (combining several features inherited from different parents, in conformance with the rules of the language) there could be more than one history branch, in this case each branch is labeled Branch #X.

The next button, Descendant versions, similarly tells you all that happens to a feature in the descendants of the current class.

Who has the same name?

The last button, Homonyms, displays all the features of the system which, related or not to the current feature by redeclaration, have the same name. You can then explore any such feature to see if the relationship is more than casual.

In any system or library that takes advantage of inheritance and its associated mechanisms -- renaming, redefinition, effecting, undefinition, multiple and repeated inheritance, polymorphism, dynamic binding -- the feature browsing facilities that we have just explored are invaluable to track what happens to features. What makes them even more precious is their connection with the rest of the browsing and documentation capabilities, especially the pick-and-drop which we will now study.

Retargeting Through Pick-and-Drop

You now know quite a few ways of re-targeting a Development Window to a "development object" -- a class or a feature -- but haven't yet seen one of the most important: "Pick-and-Drop", which lets you pick a development object that you have spotted anywhere in the display, and retarget the current tool, or another, to it.

Trying Pick-and-Drop

We restart from the last state, with a Development Window target to feature forth of class LIST. The next figure shows the whole window; it should look like what you see as a result of the last operations. We'll use the Descendant versions view of the Feature Tab.

If for some reason the window doesn't look like the next figure, it's easy to reconstruct it: make sure both the Cluster tree and the Feature tree are visible (if not, make visible using the instructions given in Viewing Classes); target the tool to class LIST; target further to its feature forth by clicking that feature name in the Features tool's roll of the features of LIST; make sure both the top-left Editing tool and the bottom-left Feature tool are visible; in the Feature tool, select the Descendant versions format.

In the Feature tool near the bottom, there is an entry that reads

	MULTI_ARRAY_LIST [G]      forth

referring to the version of feature forth in class MULTI_ARRAY_LIST. Let's assume you want to see what that version actually is. It suffices to retarget the tool to it. Of course you could type or copy-paste the class name MULTI_ARRAY_LIST in the Class field at the top of the window, and the feature name forth in the adjacent Feature field. But there is an easier way; after all, you have just seen a reference to the feature, through its name as it appears in the Descendant version format, so it's natural to use it directly from the graphical interface.

As we've seen before, you could control-right-click on the feature name at the place where it appears; this would create a new tab and retarget the Development Window to forth from MULTI_ARRAY_LIST. But you might not necessarily want a new tab. Instead you can use Pick-and-Drop to retarget the current window.

Here is how it works. Position the cursor on the desired feature reference: the word forth in the line forth MULTI_ARRAY_LIST. Right-click, that is to say click the rightmost mouse button and then release it. You will see a context menu that looks like the figure below.

The item we want to choose from this menu is "Pick Feature 'forth'". So do that now, by left-clicking over the item.

Now move the mouse around some, but without pressing any button:

The cursor has changed into a new shape, a cross representing the type of development object that you have picked, a feature. For a class, as you may have guessed, it would be a small ellipse ("bubble"). Each kind of development object that you may create and manipulate during your work with EiffelStudio has its distinctive icon. When you pick an item, you'll notice that the item's icon stays connected to its origin by a dotted line that stretches or shrinks as you move the icon around.

So, now you have picked the feature forth. You can drop it at any appropriate place to retarget the corresponding tool. Move your cursor (and the feature icon for forth) over the Editing tool now.

To drop, just right-click again. (That is to say, as before, press the rightmost mouse button and release it immediately.) Drop the icon representing {MULTI_ARRAY_LIST}.forth in the Editing tool.

This retargets the Development Window to the chosen feature, forth from the class MULTI_ARRAY_LIST. The Feature tool (assuming the Link Context tool option is selected), keeps its current view ( Descendant versions in the Feature tool) and now shows descendants of {MULTI_ARRAY_LIST}.forth.

Bypassing the context menu

In the example above, when you right-clicked over an item, you were presented with a "context" menu, containing choices applicable for the item you clicked. We chose to pick the item. It's possible that if you use pick-and-drop quite a bit that you might rather not see the context menu each time you right click. You can make this happen in a couple of ways. First, if you use the context menu most of the time, but you want to pick directly at other times, you can shift-right-click to bypass the context menu and pick the item immediately.

The other option is used if you want a right-click to pick by default, and only use the context menu occasionally. To make this happen, you need to change the Pick and drop (pnd) mode EiffelStudio preference. You can change this preference by following the menu path:

Tools --> Preferences...

With Pick and drop (pnd) mode set to True, you will always get a pick when you right-click over an development object. If you occasionally wish to use the context menu, then you would shift-right-click, which would cause the context menu to appear.

How Pick-and-Drop works

The Pick-and-Drop mechanism is very simple. It consists of three steps:

• Pick step: find the development object and pick it: either through the context menu, or by shift-right-click, or by right-click, depending upon EiffelStudio's Pick and Drop Mode.
• Move step: move the mouse to the desired drop point, without pressing any button.
• Drop step: right-click (again releasing the button immediately) at the drop position.

During the Move step, you can at any time cancel the whole operation simply through a left-click.

The Move step is actually optional: if the current position is a valid drop target, as explained next, you can drop immediately after the pick without moving the mouse.

Pebbles, holes, drop targets and type compatibility

The Pick-and-Drop mechanism relies on the metaphor of pebbles and holes. When you pick a development object, the cursor changes into a pebble whose shape represents the type of the development object: cluster, class, feature, run-time object ... You may then drop it into a hole, which can be a window, a tree view entry, or a hole-shaped icon. This performs the appropriate action such as retargeting a tool.

In the same way that Eiffel is a typed object-oriented language, the Pick-and-Drop mechanism is typed: you can only drop a pebble into a compatible hole. For example you may drop a class pebble into a Development Window, to retarget it to the chosen class. If you have picked a development object and have moved its pebble over an area which is an unacceptable place to drop it, you will notice that the pebble takes on its "disabled" form. An enabled class pebble (), for example, would become a disabled class pebble () for the time that it's hovering over unfriendly territory.

In Eiffel, type compatibility is not necessarily type identity, but is governed by conformance, based on inheritance and polymorphism: to an entity of type POLYGON, you may assign not only an expression of that same type, but also one of type RECTANGLE, if class RECTANGLE inherits from -- conforms to -- class POLYGON. Similarly, EiffelStudio considers that the development type "feature" conforms to "class"; this means you may drop a feature into a Development Window targeted to a class; this will retarget the tool to the feature's class and the feature itself, with the text of the class scrolled to the position of the feature.

Clickable formats

A good deal of the power of Pick-and-Drop comes from its connection with the various views of the Class and Feature tools ... and the Diagram tool which we will see later. As was mentioned when we saw these views, all the feature and class names or other graphical representations that appear in these views are clickable ; this means that you can select any of them as the source of a Pick-and-Drop.

As a result, you can quickly traverse a system and get to its essential properties by displaying the information of a class in any of the many available views -- the contract and flat contract of a class, its routines, its attributes, its clients, its ancestors, the ancestor and descendant versions of a feature, and so on -- then wherever you see a feature or class name follow the corresponding link. This proximity-based form of browsing, combined with the other techniques seen earlier, provides considerable help when you are dealing with a large, possibly complex system, and want to master its intricacies, be it for development, testing, debugging, maintenance or revision.

Other places where you can pick development objects include the icons representing classes and features in the Groups tool, Feature tool, and Favorites tool.

Semantic consistency

An important property of the pick-and-drop mechanism, shared by its cousin the right-click mechanism, has already been mentioned in this chapter: semantic consistency, which guarantees that the operations you can perform on a class, such as pick-and-drop, only depend on the development object to which you are applying the operation. It doesn't matter where you picked the object -- in any development tool under any view -- and in what form: textual, as a class or feature name; graphical representation, as a class bubble in the Diagram tool; or an icon, for example in the Groups tool, Features tool, Favorites tool.

The pebble that you see during the Move step of Pick-and-Drop represents the underlying development object -- such as a class or a feature -- regardless of how you got to it.

Behind the Pick-and-Drop conventions

Pick-and-Drop works differently from the usual Drag-and-Drop present on many computing platforms. The usual Drag-and-Drop retains a role within EiffelStudio (to move class bubbles around in the Diagram view) and you may of course have to use it for operating system functions such as copying files. But the key EiffelStudio operation is Pick-and-Drop. This technique is motivated by careful consideration of ergonomics and user comfort. In particular:

• Pick-and-Drop is much less stressful. Drag-and-Drop requires you to maintain pressure throughout the move, being careful not to drop on the wrong place. With Pick-and-Drop there is no stress: you click and release; get a drop from your coffee cup if you like (optional step); move the cursor with no pressure from your fingers or on your mind; make sure, at your leisure, to find the right drop place; and right-click again on it. At the end of the day, after many such operations, the stress reduction can make a real difference.
• With Drag-and-Drop, it's easy to lessen the pressure involuntarily and drop on the wrong place. The consequences can be damaging, especially since in such a case you may well not know where you dropped the element; after all, that wasn't intentional. It is possible, for example, to lose files that way. With Pick-and-Drop this is much less likely to happen.
• Pick-and-Drop makes it easy to cancel the operation if you change your mind: just left-click anywhere. With Drag-and-Drop you have to find an invalid place to drop; this may be difficult, or even impossible! (Sometimes pressing the Escape key works, but this is not universal.)

If you are new to EiffelStudio you may find Pick-and-Drop surprising at first. We trust you will join the ranks of EiffelStudio users who consistently rate it among the most convenient features of the environment.

Pick-and-Drop miscellany

When you start repeatedly retargeting the Class and Feature tools -- especially when set to "unlinked" behavior -- you will notice the following properties:

• In most cases, pick-and-dropping a class into the lower pane where the Class and Feature tools are docked will switch the view to the Class tool, and pick-and-dropping a feature switches to the Feature tool. This is true even if the pane is currently set to the Outputs tool or another unrelated tool.
• The view displayed in each case -- for example Ancestors for the Class tool and Flat for the Feature tool -- is default view for the corresponding tool.

You know by now that if you pick an object and drop in into the Editing tool it will retarget the Development Window and will evict the previous occupant of the current Editing tool tab and display the dropped object in that tab. But, you can also use Pick-and-Drop to create new tabs in the Editing tool. Instead of dropping into a tab, drop the pebble instead in the tab bar of the Editing tool next to existing tabs, or on the "New Tab" icon () in the Standard buttons toolbar.

The many paths to retargeting

As a conclusion to this review of Pick-and-Drop let's recapitulate the various ways we've seen for retargeting a whole Development Window or a tool to a class:

Recompiling and Editing

So far we have relied on existing class texts. Fascinating as it may be to explore excellent software such as EiffelBase, you probably want to write your own too (with the help of the reusable components in the Eiffel libraries). EiffelStudio provides a built-in editor -- as well as the ability to use some other editor if you prefer -- and sophisticated compilation mechanisms.

Recompiling

When we started, we compiled the example system. Let's recompile it, just to see. We'll see compilation entries in the Project menu, but the easiest for the moment is to use the compilation button () in the Project toolbar. Click this button. You haven't changed anything in the project since it was compiled (at least you were not supposed to!), so EiffelStudio will very quickly detect this and finish compilation. On our test platform this takes less than a second. Now of course we should see what happens if you do change something.

Editing

We don't want to touch EiffelBase classes (and in fact can't, since it is used in precompiled form), so let's focus on classes of our small root cluster. In the Groups tool, expand cluster root_cluster and click class PARENT to retarget the Development Window to it.

Make sure that the Editing Tool is big enough to display the text of the class:

The Editing Tool hosts a text editor which you can use to change the class text. Here the routine display starts by outputting a simple message; let's precede it by another line of display to check that we affected the outcome. We'll want to add the following two lines just after the do, before the first two instructions of the routine:

			io.put_string ("THIS IS SOME ADDED TEXT") 
			io.new_line

You can just use copy-paste from the example above: select the two lines with the mouse, copy them using CTRL-C (or Copy from the Edit menu), then paste them just after the do using CTRL-V (or Paste from the Edit menu). Add or remove tabs to align with the rest of the routine, so that the result will look like what's shown on the next figure. Please check the result and be careful not to introduce any mistakes; in the next section we'll study how EiffelStudio will report syntax and other errors, but right now we want to see what happens when everything is right!

Now save your changes; you may indifferently use CTRL-S, the Save entry from the Edit menu, or the Save button (), at the cursor location on the figure. (If you forget to save, the next compilation will tell you so, and ask you if from now on you want all non-saved class edits to be saved automatically.)

Recompiling and executing after a change

Next compile again, using the Compilation button. Some "degree" messages appear quickly; EiffelStudio has found out what class has changed and deduced what exactly to recompile -- only a subset of the whole system. So this again will proceed very quickly.

Execute the system again now, using one of the execution buttons, with or without breakpoints, on the right in the bottom Project toolbar. You will see that the message output by the execution has changed to include the added string.

Views in the Editing Tool

In studying the Class tool we discovered a number of views of a class text. For convenience, you can also display a number of these views in the Editing Tool, although only the basic Text view is editable. A row of buttons next to the Class and Feature fields lets you choose between them.

You can try some of these view now, although there is nothing exciting to show about class PARENT. Make sure to come back to the Text view -- through the leftmost of these buttons -- so that we can continue exploring the editing facilities.

Basic editing facilities

The editing facilities in the Editing Tool are provided by the EiffelStudio Editor, a specialized tool supporting the development and update of Eiffel texts. As we'll see next, if you have a preferred editor you can use it instead, but the EiffelStudio Editor is worth knowing.

The EiffelStudio Reference section on the Editor provides many more details about editing functions. Here are the essentials.

First, the key property of any interactive system: Undo. You can cancel the latest editing command, or any earlier one performed during the current session, by choosing Undo from the Edit menu, or typing CTRL-Z. To cancel more than one command, apply Undo repetitively; there is no limit to the number of undoable commands within a session. (When you exit EiffelStudio, however, the editing history is lost.) To redo an undone command, use Redo from the Edit menu or CTRL-Y.

Note: Since right now we don't need to do any actual editing to continue this Guided Tour, we suggest that you don't change the text of class PARENT but simply look up the menu entries described next, without actually selecting them. If you do make a change, voluntary or not, you should at the end of this editor discussion perform enough Undo commands to get the text of class PARENT back to its original state.

To copy, cut and paste use the corresponding entries in the Edit menu or the familiar keyboard shortcuts CTRL-C, CTRL-X and CTRL-V.

When you edit text, it will be automatically indented according to standard Eiffel style rules. If you prefer to remain in charge of your own indenting, you can disable this facility through

Tools --> Preferences --> Editor

To indent a sequence of lines, select the lines, then use <codeang=text> Edit --> Advanced --> Indent selection</code> You can also use the Tab key, but only if the selection consists of one or more entire lines; otherwise typing Tab will simply replace the selected text with a Tab character. Shift-Tab will similarly decrease indentation by one step.

To comment out a sequence of lines, select them and use

Edit --> Advanced --> Comment

Other useful facilities of the Edit --> Advanced menu are:

• Embed in "if", or CTRL-I, which will create a conditional instruction and include the selected instructions in it.
• Embed in "debug", CTRL-D, which will include the selected instructions in a debug ... end instruction, so that their execution becomes conditional on a Debug compilation option.