Author:halw

Date:2009-01-06T21:31:01.000000Z


git-svn-id: https://svn.eiffel.com/eiffel-org/trunk@153 abb3cda0-5349-4a8f-a601-0c33ac3a8c38

documentation/current/eiffelstudio/eiffelstudio-guided-tour/compiling-and-executing-system.wiki

@@ -6,9 +6,10 @@ EiffelStudio first comes up with a window and a dialog on top of it; the dialog
 
 [[Image:index-2]]
 
-As this is our first project we want to <code> Add Project. </code> We could also 
+
-* " <code lang="c"> Create project </code>", 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. 
+As this is our first project we want to <code>Add Project</code> . We could also 
-* " <code> Open project </code>", which would let you open a previously added project.. 
+* "<code lang="c">Create project</code>", 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. 
+* "<code>Open project</code>", which would let you open a previously added project.. 
 
 In future sessions you'll probably use the first option for a new project, as it takes care of generating everything for you, and the second option for an existing project.
 
@@ -17,13 +18,14 @@ Right now you first have to add the project, so click on <code>Add Project</code
 	$ISE_EIFFEL\examples\studio\tour\simple.ecf
 </code>
 
-remember that <code> $ISE_EIFFEL </code> stands for the location of the Eiffel installation, such as <code> C:\Eiffel50 </code> ; ECF files are normally marked by the <code> .ecf </code> file extension). 
+remember that <code>$ISE_EIFFEL</code> stands for the location of the Eiffel installation, such as <code>C:\Eiffel63</code> ; ECF files are normally marked by the <code>.ecf</code> file extension). 
 
-Use the File Explorer to go to the directory <code> $ISE_EIFFEL/examples/studio/tour/ </code> and select the appropriate file. You will then be back on the startup dialog. 
+Use the File Explorer to go to the directory <code>$ISE_EIFFEL/examples/studio/tour/</code> and select the appropriate file. You will then be back on the startup dialog. 
 
 [[Image:index-3]]
 
-Click <code> Open </code> to confirm. This starts compilation of your project. 
+
+Click <code>Open</code> to confirm. This starts compilation of your project. 
 
 During Eiffel compilation, a progress bar displays the successive compilation steps, or "degrees". The bulk of our little project is the EiffelBase library, which the EiffelStudio installation procedure has precompiled; so just now there's only a few extra classes to compile, and the process is almost instantaneous on a state-of-the-art computer. Even if you had to compile the EiffelBase classes, EiffelStudio compilation is so fast that you would hardly have the time to read the "degree" messages; you can see them later in compilations of bigger classes and systems.
 
@@ -44,11 +46,12 @@ The system doesn't do anything exciting, but let's execute it anyway. Find the e
 
 It would be OK too to use the neighboring icon to the left, "Run without breakpoints", since we haven't set any breakpoints. Click either icon to execute the system.
 
-This little application doesn't use graphics or anything fancy but simply creates some objects and displays some information. Output done using the default Eiffel I/O (from the EiffelBase classes <code> ANY </code> and <code> STANDARD_FILES </code> ) goes to a console. On Unix/Linux and OpenVMS it's the window from which you started EiffelStudio. On Windows it's by default a new console window that comes up when and if the system does its first output operation, and stays up: 
+This little application doesn't use graphics or anything fancy but simply creates some objects and displays some information. Output done using the default Eiffel I/O (from the EiffelBase classes <code>ANY</code> and <code>STANDARD_FILES</code> ) goes to a console. On Unix/Linux and OpenVMS it's the window from which you started EiffelStudio. On Windows it's by default a new console window that comes up when and if the system does its first output operation, and stays up: 
 
 [[Image:index-6]]
 
-The message " <code> Press Return to finish the execution </code>" 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 since there is no new console window to get rid of.) 
 
-If before closing the console window you look at the main EiffelStudio window (by moving away the console window) you will notice that it looks different from before, since it now shows the fields useful in monitoring execution and debugging. But we'll look at this later. For the moment just dismiss the console by following the advice to " <code> Press Return </code>": hit the Return or Enter key. 
+The message "<code>Press Return to finish the execution</code>" 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 since there is no new console window to get rid of.) 
+
+If before closing the console window you look at the main EiffelStudio window (by moving away the console window) you will notice that it looks different from before, since it now shows the fields useful in monitoring execution and debugging. But we'll look at this later. For the moment just dismiss the console by following the advice to "<code>Press Return</code>": hit the Return or Enter key. 
 

documentation/current/eiffelstudio/eiffelstudio-guided-tour/copying-example-files.wiki

@@ -4,22 +4,22 @@
 [[Property:uuid|bb8ff7d7-2e93-d150-339c-d9afb967bc98]]
 {{note|If you are using Eiffel on a personal computer under Windows, you can work directly on the installation directory and don't need to make copies of files as per the present section. Skip directly to the next section, 3. Do read the present section and apply its instructions if you work under Unix, 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.}}
 
-If you are going to work on a copy, choose or create a directory of your own; let's call it <code> YOURDIR </code> for the rest of the discussion. 
+If you are going to work on a copy, choose or create a directory of your own; let's call it <code>YOURDIR</code> for the rest of the discussion. 
 
-To copy all the files of the example to <code> YOURDIR </code>: 
+To copy all the files of the example to <code>YOURDIR</code>: 
-* On Windows, open a Windows Explorer, go to <code> $ISE_EIFFEL\examples\studio\tour </code>, select all the files in that directory, and drag-and-drop them to <code> YOURDIR </code>. 
+* On Windows, open a Windows Explorer, go to <code>$ISE_EIFFEL\examples\studio\tour</code> , select all the files in that directory, and drag-and-drop them to <code>YOURDIR</code> . 
 * On Unix execute the shell command 
 <code lang="text">
-	cp $ISE_EIFFEL/examples/studio/tour/* YOURDIR</code>
+cp $ISE_EIFFEL/examples/studio/tour/* YOURDIR</code>
 
 * On OpenVMS execute the command 
 <code lang=text">
-	copy $ISE_EIFFEL:[examples.studio.tour]*.* YOURDIR</code>
+copy $ISE_EIFFEL:[examples.studio.tour]*.* YOURDIR</code>
 
 
-Once you have compiled the example under EiffelStudio, relying on the precompiled EiffelBase library (the default), and without optimization, the contents of <code> YOURDIR </code> will take up less than one megabyte, including information on diagrams and metrics. 
+Once you have compiled the example under EiffelStudio, relying on the precompiled EiffelBase library (the default), and without optimization, the contents of <code>YOURDIR</code> will take up less than one megabyte, including information on diagrams and metrics. 
 
-The final executable generated through " ''finalization''" (optimized compilation) will take only about 300 kilobytes. 
+The final executable generated through "''finalization''" (optimized compilation) will take only about 300 kilobytes. 
 
 Without precompiled EiffelBase you would need about 3.5 megabytes, plus about 25 megabytes of generated C code and auxiliary files. The executable in that case will take up about 250 kilobytes. 
 

documentation/current/eiffelstudio/eiffelstudio-guided-tour/look-project-directory.wiki

@@ -6,22 +6,22 @@ Before we proceed with the facilities of the environment, let's take a look at t
 
 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 going to the <code> File </code> <code> --> </code> <code> New Project </code> menu, but please '''don't select that menu entry now''' as we have many more things to do with our current project first. 
+Every session is relative to a project; you can start a new project from within EiffelStudio by going to the <code>File  -->  New Project</code> menu, but please '''don't select that menu entry now''' as we have many more things to do with our current project first. 
 
 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, but that is not required; the source files and ecf may reside anywhere. Some users, in fact, like to put nothing else 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 <code> YOURDIR </code> (either <code> $ISE_EIFFEL\examples\studio\tour </code> or the copy that you have made). Go to that project directory using the Windows explorer or a <code> cd </code> command, and look at its contents (using <code> ls </code> on Unix/Linux): 
+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 <code>YOURDIR</code> (either <code>$ISE_EIFFEL\examples\studio\tour</code> or the copy that you have made). Go to that project directory using the Windows explorer or a <code>cd</code> command, and look at its contents (using <code>ls</code> on Unix/Linux): 
 
 [[Image:index-7]]
 
-The contents of this <code> YOURDIR </code> directory include the following: 
+The contents of this <code>YOURDIR</code> directory include the following: 
-* First you see a number of files with the extension <span>.</span> <code> e </code>, for "Eiffel": <code> heir.e </code>, <code> invalid.e </code> and others. These are the Eiffel source files, each containing one class. The recommended convention is to store a class of name <code> CLASS_NAME </code> into a file of name <code> class_name </code> <code> .e </code>, where <code> class_name </code> is the lower-case version of <code> CLASS_NAME </code> ; here, file <code> heir.e </code> contains the class <code> HEIR </code> 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 <code> class_name </code> <code> .e </code> is only a recommendation, not an obligation; but you <span>are</span> required to store one class per file. This keeps things simple and facilitates project and configuration management. 
+* First you see a number of files with the extension <code>.e</code> , for "Eiffel": <code>heir.e </code>, <code> invalid.e </code> and others. These are the Eiffel source files, each containing one class. The recommended convention is to store a class of name <code>CLASS_NAME</code> into a file of name <code>class_name.e </code>, where <code>class_name</code> is the lower-case version of <code>CLASS_NAME</code> ; here, file <code>heir.e</code> contains the class <code>HEIR</code> 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 <code>class_name.e</code> is only a recommendation, not an obligation; but you <span>are</span> required to store one class per file. This keeps things simple and facilitates project and configuration management. 
-* You also notice a file with an <code> ecf </code> 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 " <code> Create project </code>" 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 are written in a xml notation. 
+* You also notice a file with an <code>ecf</code> 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 are written in a xml notation. 
-* Finally you will notice a subdirectory called <code> EIFGENs </code>, for " <code> EIF </code>fel <code> GEN </code>eration<code>s</code>". <code> EIFGENs </code> 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 <code> EIFGENs </code> 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 <code> EIFGENs </code>. 
+* Finally you will notice a subdirectory called <code>EIFGENs</code>, for "<code>EIF</code>fel <code>GEN</code>eration<code>s</code>". <code>EIFGENs</code> 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 <code>EIFGENs</code> 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 <code>EIFGENs</code>. 
 
-Later on, we will see that EiffelStudio may generate three more subdirectories of the project directory: <code> Diagrams </code>, if you produce graphical system diagrams; <code> Documentation </code>, if you request system documentation, for example HTML; and <code> Metrics </code>, if you perform measurements on your system. Other than these directories, <code> EIFGENs </code> EiffelStudio will not touch anything in the project directory, so you may safely add and change whatever files and subdirectories you like. 
+Later on, we will see that EiffelStudio may generate three more subdirectories of the project directory: <code>Diagrams</code>, if you produce graphical system diagrams; <code>Documentation</code>, if you request system documentation, for example HTML; and <code>Metrics</code>, if you perform measurements on your system. Other than these directories, <code>EIFGENs</code> 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 <code> EIFGENs </code>, although you should know that it's there. Right now if you check the contents of the project directory <code> YOURDIR </code> (using the Windows Explorer on Windows, the <code> ls </code> command on Unix, or some equivalent mechanism), you will see that <code> EIFGENs </code> has been created, itself with a subdirectory called <code>classic</code> which is the name of the target and which has some subdirectories, including <code> W_Code </code> which contains the generated code ( <code> W </code> for "Workbench" -- we'll see the reason later). Feel free to browse through it if you like, but don't change anything. 
+You seldom need to look into <code>EIFGENs</code>, although you should know that it's there. Right now if you check the contents of the project directory <code>YOURDIR</code> (using the Windows Explorer on Windows, the <code>ls</code> command on Unix, or some equivalent mechanism), you will see that <code>EIFGENs</code> has been created, itself with a subdirectory called <code>classic</code> which is the name of the target and which has some subdirectories, including <code>W_Code</code> which contains the generated code ( <code>W</code> 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.
 

documentation/current/eiffelstudio/eiffelstudio-guided-tour/overview-and-prerequisites.wiki

@@ -46,7 +46,7 @@ Please execute user actions, such as clicking, only when asked to do so.
 
 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 ( <code> cd </code> ) and listing the files of a directory ( <code> ls </code> ).
+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 ( <code>cd</code> ) and listing the files of a directory ( <code>ls</code> ).
 
 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 <span>is</span> different, and it may take a while before you fully understand why it does some things in a certain way.
 
@@ -58,7 +58,7 @@ Once an EiffelStudio session has been started, you can largely forget about the
 
 Windows users should particularly note the following two conventions of terminology:
 * Operating systems store files into hierarchically nested structures called <span>folders</span> or <span>directories</span>. 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 <span>path name</span>, used to describe how to reach it from the root of its file system, as in <code> c:\d1\d2\f </code>. This example uses the Windows notation, which separates successive components of a path name by a backward slash character <code> \ </code>. On Unix and Linux, the separator is a forward slash <code> / </code>, as in <code> /d1/d2/f </code> ; 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. 
+* A file has a full <span>path name</span>, used to describe how to reach it from the root of its file system, as in <code>c:\d1\d2\f</code> . This example uses the Windows notation, which separates successive components of a path name by a backward slash character <code>\</code> . On Unix and Linux, the separator is a forward slash <code>/</code> , as in <code>/d1/d2/f</code> ; 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.
 
@@ -68,7 +68,7 @@ If you are a one-platform person, just ignore, for the next few pages, all refer
 
 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 <code> ISE_EIFFEL </code> must be set to the installation directory, and the environment variable <code> ISE_PLATFORM </code> 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 <code> $ISE_EIFFEL </code> and <code> $ISE_PLATFORM </code> will refer to the values of these variables -- the installation directory, and the platform. (The Windows notation would be <code> %ISE_EIFFEL% </code> and <code> %ISE_PLATFORM% </code>.) 
+* The environment variable <code> ISE_EIFFEL </code> must be set to the installation directory, and the environment variable <code>ISE_PLATFORM</code> 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 <code>$ISE_EIFFEL</code> and <code>$ISE_PLATFORM</code> will refer to the values of these variables -- the installation directory, and the platform. (The Windows notation would be <code>%ISE_EIFFEL%</code> and <code>%ISE_PLATFORM%</code>.) 
 * 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.
 
@@ -77,5 +77,5 @@ To run the example you must have installed EiffelStudio and set up the environme
 Please take a moment to locate the example files on your installation. They all appear in the following directory, part of the Eiffel delivery:
 <code>$ISE_EIFFEL/examples/studio/tour</code>
 
-(Windows users: remember that instead of the slash <code> / </code> your platform uses a backslash <code> \ </code>. OpenVMS users: this is to be replaced by the OpenVMS path naming conventions.) 
+(Windows users: remember that instead of the slash <code>/</code> your platform uses a backslash <code>\</code> . OpenVMS users: this is to be replaced by the OpenVMS path naming conventions.) 
 

documentation/current/eiffelstudio/eiffelstudio-guided-tour/starting-browse.wiki

@@ -20,9 +20,9 @@ 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. When it first comes up, EiffelStudio initially uses a fairly small window, because it's designed to run on a 800x600 display, although of course a bigger display is recommended. But as soon as you have resized it, EiffelStudio will come up, in the next session, with the size you've set.'' }}
 
-You can see five panes, marked on the figure: <code> Features </code>, <code> Class </code>, <code> Properties </code>, <code> Clusters </code>, <code> Context </code>. There will be others, such as <code> Search </code>, and you can remove any of them, except <code> Class </code>, at any time to make room for the others. 
+You can see five panes, marked on the figure: <code>Features</code>, <code>Class</code>, <code>Properties</code>, <code>Clusters</code>, <code>Context</code>. There will be others, such as <code>Search</code>, and you can remove any of them, except <code>Class</code>, at any time to make room for the others. 
 
-So far we have talked about " <span>the</span> EiffelStudio window", but in fact that's not correct. What you see is <span>one</span> " '''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 <code> File </code> menu at the top left -- don't select any of these entries yet, just look -- you'll see, among others, <code> New window </code>, which would create a new Development Window. 
+So far we have talked about " <span>the</span> EiffelStudio window", but in fact that's not correct. What you see is <span>one</span> " '''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 <code>File</code> menu at the top left -- don't select any of these entries yet, just look -- you'll see, among others, <code>New window</code>, 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. 
 
@@ -32,19 +32,19 @@ Our first example screen was targeted to the whole system. To retarget it to a p
 
 [[Image:index-9]]
 
-Let's use one of the most basic classes, <code> ARRAY </code> from the Kernel Library of EiffelBase. Bring the cursor to the Class Field, click to make it active, type <code> array </code> (or <code> ARRAY </code> ) and the Enter key. As shown on the next figure, this retargets the tool to class <code> ARRAY </code>. Note that you didn't have to worry about where the class resides in the files of your computer. Also, the Class Field will now show the target's class name, <code> ARRAY </code>, in upper case, since that is the standard Eiffel convention for class names. 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 back in all upper case. 
+Let's use one of the most basic classes, <code>ARRAY</code> from the Kernel Library of EiffelBase. Bring the cursor to the Class Field, click to make it active, type <code>array</code> (or <code>ARRAY</code> ) and the Enter key. As shown on the next figure, this retargets the tool to class <code>ARRAY</code>. Note that you didn't have to worry about where the class resides in the files of your computer. Also, the Class Field will now show the target's class name, <code>ARRAY</code>, in upper case, since that is the standard Eiffel convention for class names. 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 back in all upper case. 
 
 [[Image:index-10]]
 
-The Development Window is now targeted to class <code> ARRAY </code>. Each of the four panes contains a tool: 
+The Development Window is now targeted to class <code>ARRAY</code>. Each of the four panes contains a tool: 
-* Features Tree, top-left: a tree view of all the features of the class, grouped by the feature categories ( <code> Initialization </code>, <code> Access </code>, <span>...</span> ) as they appear in the class. 
+* Features Tree, top-left: a tree view of all the features of the class, grouped by the feature categories ( <code>Initialization</code>, <code>Access</code>, <span>...</span> ) as they appear in the class. 
-* Editing Tool, top-right: the source text of the class, editable. For the moment the pane is too small to display much of interest -- it only shows the very first few lines -- but we'll enlarge it when we need to modify class texts. (Not <code> ARRAY </code>, though, as it's not the kind of class you want to change during your first session with EiffelStudio, so just wait a bit.) 
+* Editing Tool, top-right: the source text of the class, editable. For the moment the pane is too small to display much of interest -- it only shows the very first few lines -- but we'll enlarge it when we need to modify class texts. (Not <code>ARRAY</code>, though, as it's not the kind of class you want to change during your first session with EiffelStudio, so just wait a bit.) 
 * Cluster Tree, bottom-left: a tree view of the clusters of the system.
-* Context Tool, bottom right: a bag full of neat tricks. At the moment it just shows some general information about the system (where it resides, the name of its root class <code> TESTROOT </code> ), but more generally it's there to give you all kinds of interesting views of the system, through the various tabs at the bottom: <code> Output </code>, <code> Diagram </code>, <code> Class </code>, <code> Feature </code>, <code> Metric </code>, <code> External Output </code>, <code> C Output </code>, <code> Errors </code>, <code> Warnings </code>. 
+* Context Tool, bottom right: a bag full of neat tricks. At the moment it just shows some general information about the system (where it resides, the name of its root class <code>TESTROOT</code> ), but more generally it's there to give you all kinds of interesting views of the system, through the various tabs at the bottom: <code>Output</code>, <code>Diagram</code>, <code>Class</code>, <code>Feature</code>, <code>Metric</code>, <code>External Output</code>, <code>C Output</code>, <code>Errors</code>, <code>Warnings</code>. 
 
 ==A peek at diagram==
 
-There's indeed a lot in the Context Tool, too much to see right now, but to feed our curiosity let's just take a peek at the Diagram View. Click the <code> Diagram </code> Tab at the bottom: 
+There's indeed a lot in the Context Tool, too much to see right now, but to feed our curiosity let's just take a peek at the Diagram View. Click the <code>Diagram</code> Tab at the bottom: 
 
 [[Image:index-11]]
 
@@ -52,13 +52,13 @@ This displays a class diagram in the Context Tool:
 
 [[Image:index-12]]
 
-{{note| ''If nothing appears in the Context Tool when you click the Diagram Tab, that's because the Context Tool and the Class View are not linked. Linking the two tools together will ensure that whenever a change is made in one tool the other will update to reflect that change. To link the tools select the menu entry '' <code> View </code> <code> --> </code> <code> Link context tool </code> ''; this will display the diagram as shown. We'll see the explanation for this behavior in '' [[10 RETARGETING THROUGH PICK-AND-DROP| ''Isolating the context, pg 68'' ]]  }}
+{{note| ''If nothing appears in the Context Tool when you click the Diagram Tab, that's because the Context Tool and the Class View are not linked. Linking the two tools together will ensure that whenever a change is made in one tool the other will update to reflect that change. To link the tools select the menu entry '' <code>View</code> <code>--></code> <code>Link context tool</code> ''; this will display the diagram as shown. We'll see the explanation for this behavior in '' [[10 RETARGETING THROUGH PICK-AND-DROP| ''Isolating the context, pg 68'' ]]  }}
 
 The diagram is cropped to the available area; to get the whole picture, resize the window from the bottom-right corner. You can now see the inheritance structure:
 
 [[Image:index-13]]
 
-The red arrows show <span>inheritance</span> relations: <code> STRING </code> inherits from <code> INDEXABLE </code> and so on. We'll see later how to display the other key inter-class relation, <span>client</span>, but it's not particularly interesting for <code> STRING </code>. The default placement of the classes is quite good in this case, but if you don't like it you can change it; your changes will be retained the next time you bring up this diagram, in this session or a later one. (That's part of the information the <code> Diagram </code> directory keeps.) It will also be used in Web diagrams if you choose to generate an HTML form. To move a class bubble, just use standard drag-and-drop. For example you may move everything to the left and make the figure more compact: 
+The red arrows show <span>inheritance</span> relations: <code>STRING</code> inherits from <code>INDEXABLE</code> and so on. We'll see later how to display the other key inter-class relation, <span>client</span>, but it's not particularly interesting for <code>STRING</code>. The default placement of the classes is quite good in this case, but if you don't like it you can change it; your changes will be retained the next time you bring up this diagram, in this session or a later one. (That's part of the information the <code>Diagram</code> directory keeps.) It will also be used in Web diagrams if you choose to generate an HTML form. To move a class bubble, just use standard drag-and-drop. For example you may move everything to the left and make the figure more compact: 
 
 [[Image:index-14]]
 
@@ -66,43 +66,43 @@ Later on you will learn how to use the Diagram View not just to display system s
 
 ==Retargeting from the Cluster Tree==
 
-Your first browsing action used a class of which you knew the name, <code> STRING </code>. What if you don't know what's in the system and want to explore it? Among other techniques, you can let the Cluster Tree, in the Cluster Tool at the bottom left of the Development Window, guide you through the system's structure: 
+Your first browsing action used a class of which you knew the name, <code>STRING</code>. What if you don't know what's in the system and want to explore it? Among other techniques, you can let the Cluster Tree, in the Cluster Tool at the bottom left of the Development Window, guide you through the system's structure: 
 
 [[Image:index-15]]
 
-An Eiffel system, as you know, is organized into clusters and libraries (and assemblies on some .NET systems), clusters can be structured hierarchically into subclusters. Here we see one cluster: <code> root_cluster </code>, containing the few classes specific to our Guided Tour system. There are also two libraries: <code>base</code> which provides the base classes and <code>precompile</code> which does not provide any classes directly (precompiles are present to speed up compilation time by precompiling classes). Let's go into <code> base </code>, ISE's open-source library of fundamental reusable mechanisms. Click the little <code> + </code> sign to the left of its name; this expands the clusters and libraries in the base library. Expand now the base cluster and you will see the its six subclusters: <code> event </code> for event handling, <code> kernel </code> for the Kernel Library, <code> refactoring </code> for help with refactoring, <code> serialization </code> for serialization, <code> structures </code> for the Data Structure Library, and <code> support </code> for additional supporting mechanisms. 
+An Eiffel system, as you know, is organized into clusters and libraries (and assemblies on some .NET systems), clusters can be structured hierarchically into subclusters. Here we see one cluster: <code>root_cluster</code>, containing the few classes specific to our Guided Tour system. There are also two libraries: <code>base</code> which provides the base classes and <code>precompile</code> which does not provide any classes directly (precompiles are present to speed up compilation time by precompiling classes). Let's go into <code>base</code>, ISE's open-source library of fundamental reusable mechanisms. Click the little <code>+</code> sign to the left of its name; this expands the clusters and libraries in the base library. Expand now the base cluster and you will see the its six subclusters: <code>event</code> for event handling, <code>kernel</code> for the Kernel Library, <code>refactoring</code> for help with refactoring, <code>serialization</code> for serialization, <code>structures</code> for the Data Structure Library, and <code>support</code> for additional supporting mechanisms. 
 
 [[Image:index-16]]  
 
-The most extensive of these EiffelBase libraries is <code> structures </code>, which contains implementations of major data structures and algorithms of computing science. Click the <code> + </code> next to <code> structures </code> to see its own subclusters: 
+The most extensive of these EiffelBase libraries is <code>structures</code>, which contains implementations of major data structures and algorithms of computing science. Click the <code>+</code> next to <code>structures</code> to see its own subclusters: 
 
 [[Image:index-17]]
 
 {{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 possibly scrolling.'' }}
 
-The EiffelBase Data Structure library and its subclusters are described in the book <span> [http://www.eiffel.com/doc/ Reusable Software]  </span>. Let's go to one of the most frequently used subclusters, <code> list </code>, containing implementations of list structures. Click the <code> + </code> next to <code> list </code>. This time, since list is a terminal cluster, it's not subclusters you'll see, but '''classes''', identified by small ellipses: 
+The EiffelBase Data Structure library and its subclusters are described in the book <span> [http://www.eiffel.com/doc/ Reusable Software]  </span>. Let's go to one of the most frequently used subclusters, <code>list</code>, containing implementations of list structures. Click the <code>+</code> next to <code>list</code>. This time, since list is a terminal cluster, it's not subclusters you'll see, but '''classes''', identified by small ellipses: 
 
 [[Image:index-18]]
 
 The ellipse, or "bubble", is indeed throughout EiffelStudio, as in the Business Object Notation (BON, the underlying graphical convention), the distinctive symbol for classes; remember the larger bubbles showing classes in the Diagram View a few moments ago.
 
-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 Cluster Tree. Do this now: click <code> LIST </code> in the tree. It doesn't matter whether you click on the class name or the adjacent bubble. This retargets the tool to class <code> LIST </code>. Because the Context Tool is still in <code> Diagram </code> view, it will display the inheritance structure for the new target class: 
+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 Cluster Tree. Do this now: click <code>LIST</code> in the tree. It doesn't matter whether you click on the class name or the adjacent bubble. This retargets the tool to class <code>LIST</code>. Because the Context Tool is still in <code>Diagram</code> view, it will display the inheritance structure for the new target class: 
 
 [[Image:index-19]]
 
-While this view is being produced you may see (or just get a glimpse of, if your machine is fast) messages indicating that it's producing the diagram for <code> LIST </code>. In a moment we'll switch views in the Context Tool as we won't need the diagrams. 
+While this view is being produced you may see (or just get a glimpse of, if your machine is fast) messages indicating that it's producing the diagram for <code>LIST</code>. In a moment we'll switch views in the Context Tool as we won't need the diagrams. 
 
-As the tool is now targeted to <code> LIST </code>, 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 <code> STRING </code> in the previous method of retargeting. 
+As the tool is now targeted to <code>LIST</code>, 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 <code>STRING</code> 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 <code> Back </code> and <code> Forth </code> buttons, which will enable you to revisit classes already seen during the current session: 
+Here now is a third way to retarget. Towards the top-left part of the Development Window there are <code>Back</code> and <code>Forth</code> buttons, which will enable you to revisit classes already seen during the current session: 
 
 [[Image:index-20]]
 
-Click the <code> Back </code> button. This retargets the tool to the class you visited previously: <code> STRING </code>. The <code> Forth </code> button, immediately to the right of <code> Back </code>, becomes active. Click it to retarget back to <code> LIST </code>. 
+Click the <code>Back</code> button. This retargets the tool to the class you visited previously: <code>STRING</code>. The <code>Forth</code> button, immediately to the right of <code>Back</code>, becomes active. Click it to retarget back to <code>LIST</code>. 
 
-Note that all buttons of the interface have a "tooltip": 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. You may try this now on the <code> Back </code> and <code> Forth </code> buttons. 
+Note that all buttons of the interface have a "tooltip": 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. You may try this now on the <code>Back</code> and <code>Forth</code> buttons. 
 
 ==The Target History==
 
@@ -110,19 +110,19 @@ As a fourth way to retarget -- there are more, and after this one we'll stop cou
 
 [[Image:index-21]]
 
-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, <code> STRING </code> and <code> LIST </code>, but later on there will be more entries. By default EiffelStudio remembers 10 classes; this is one of the settings you can change later if you wish, through the menu <code> Tools </code> <code> --> </code> <code> Preferences </code>. (There's no point in doing this now.) 
+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, <code>STRING</code> and <code>LIST</code>, but later on there will be more entries. By default EiffelStudio remembers 10 classes; this is one of the settings you can change later if you wish, through the menu <code>Tools</code> <code>--></code> <code>Preferences</code>. (There's no point in doing this now.) 
 
 ==Adding to Favorites==
 
 If you find yourself often needing to examine a particular class, you can add it to your "Favorites", similar to the favorites, also called <span>bookmarks</span>, which you use to retain interesting pages in a Web browser. 
 
-It's easy to add the current target -- currently, <code> LIST </code> -- to your Favorites. Do it now: go to the <code> Favorites </code> menu and select <code> Add to favorites </code>. Now display the favorites; one way is to go back to that same Favorites menu and select <code> Show favorites </code>. The Favorites Tool appears below the Cluster Tree: 
+It's easy to add the current target -- currently, <code>LIST</code> -- to your Favorites. Do it now: go to the <code>Favorites</code> menu and select <code>Add to favorites</code>. Now display the favorites; one way is to go back to that same Favorites menu and select <code>Show favorites</code>. The Favorites Tool appears below the Cluster Tree: 
 
 [[Image:index-22]] 
 
-This also means one more way to retarget a Development Window: click a class in the Favorites Tool. <span>Two</span> ways actually, since even if you don't see the Favorites Tool the class will appear in the <code> Favorites </code> menu and you can select it there. 
+This also means one more way to retarget a Development Window: click a class in the Favorites Tool. <span>Two</span> ways actually, since even if you don't see the Favorites Tool the class will appear in the <code>Favorites</code> menu and you can select it there. 
 
-Right now we don't need the Favorites Tool, so you can get rid of it by either selecting <code> Hide favorites </code> in the <code> Favorites </code> menu or clicking the little Close icon at the top right of the Favorites Tool: 
+Right now we don't need the Favorites Tool, so you can get rid of it by either selecting <code>Hide favorites</code> in the <code>Favorites</code> menu or clicking the little Close icon at the top right of the Favorites Tool: 
 
 [[Image:index-23]]
 
@@ -130,11 +130,11 @@ Right now we don't need the Favorites Tool, so you can get rid of it by either s
 
 With all the techniques seen so far, you were able to retarget the current Development Window to a new class. As noted, you may also wish to have two or more Development Windows targeted to different classes; this is useful to keep track of several things at once. A simple way to start a new tool on a class is to find the class somewhere in the interface and '''control-right-click''' it. 
 
-Here, for example, the editor lists <code> CHAIN </code>, as a parent of <code> LIST. </code> Go to that word and control-right-click it, that is to say, click with the rightmost button of the mouse while holding the CONTROL key on the keyboard. This starts a new Development Window, targeted to the chosen class, <code> CHAIN </code> : 
+Here, for example, the editor lists <code>CHAIN</code>, as a parent of <code>LIST.</code> Go to that word and control-right-click it, that is to say, click with the rightmost button of the mouse while holding the CONTROL key on the keyboard. This starts a new Development Window, targeted to the chosen class, <code>CHAIN</code> : 
 
 [[Image:index-24]]
 
-The place where we found the class <code> CHAIN </code> in the original tool (the one targeted to <code> LIST </code> ) was the bubble representing the class in the Diagram View. But that's just one possibility. A general principle of EiffelStudio is '''semantic consistency''' : when you want to work with a development object -- a class, a feature, a cluster -- you can grab it wherever it appears in the interface, and in whatever format it is displayed: you might have spotted it be in the Diagram View, in the text of a class in the Editing Tool, in the Cluster or Feature Tree, or in any of the class documentation formats that we will soon see; and the form under which you found it may be text -- the name of the class in a text document -- or some graphical representation, such as a class bubble in a diagram. These variants don't matter: if the class or other development object catches your fancy, you can do whatever operations make sense for it, such as Control-right-click to start a new development object targeted to it, or any of the other operations we'll see next. 
+The place where we found the class <code>CHAIN</code> in the original tool (the one targeted to <code>LIST</code> ) was the bubble representing the class in the Diagram View. But that's just one possibility. A general principle of EiffelStudio is '''semantic consistency''' : when you want to work with a development object -- a class, a feature, a cluster -- you can grab it wherever it appears in the interface, and in whatever format it is displayed: you might have spotted it be in the Diagram View, in the text of a class in the Editing Tool, in the Cluster or Feature Tree, or in any of the class documentation formats that we will soon see; and the form under which you found it may be text -- the name of the class in a text document -- or some graphical representation, such as a class bubble in a diagram. These variants don't matter: if the class or other development object catches your fancy, you can do whatever operations make sense for it, such as Control-right-click to start a new development object targeted to it, or any of the other operations we'll see next. 
 
-While you are at it, try a couple of other ways to create a new Development Window. Go to <code> File </code> <code> --> </code> <code> New window </code> ; this creates a new tool, untargeted. The title bar says " <code> Empty development tool #1 </code> ". You can get the same effect by clicking the Create New Window icon, leftmost on the top row of buttons, just below " <code> File </code>". The corresponding keyboard accelerator is CTRL- <code> N </code>. 
+While you are at it, try a couple of other ways to create a new Development Window. Go to <code>File</code> <code>--></code> <code>New window</code> ; this creates a new tool, untargeted. The title bar says " <code>Empty development tool #1</code> ". You can get the same effect by clicking the Create New Window icon, leftmost on the top row of buttons, just below " <code>File</code>". The corresponding keyboard accelerator is CTRL- <code>N</code>. 
 

documentation/current/eiffelstudio/eiffelstudio-guided-tour/starting-eiffelstudio-and-opening-project.wiki

@@ -2,7 +2,7 @@
 [[Property:link_title|Starting EiffelStudio and Opening a Project]]
 [[Property:weight|-13]]
 [[Property:uuid|676cf329-5640-69c4-d10b-b56fcd3f2ff9]]
-In the rest of this Tour <code> YOURDIR </code> denotes the directory where the example resides (the original, <code> $ISE_EIFFEL/examples/studio/tour </code>, 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. 
+In the rest of this Tour <code>YOURDIR</code> denotes the directory where the example resides (the original, <code>$ISE_EIFFEL/examples/studio/tour</code> , 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==
 
@@ -17,11 +17,11 @@ If this is the first time you are using EiffelStudio, you may get a dialog askin
 
 ==Launching EiffelStudio under Unix or OpenVMS==
 
-To launch EiffelStudio on Unix or OpenVMS, change directory to <code> YOURDIR </code> and, from the command line, type 
+To launch EiffelStudio on Unix or OpenVMS, change directory to <code>YOURDIR</code> and, from the command line, type 
 <code lang="text">
-	estudio
+estudio
 </code>
 
-In general you can start EiffelStudio from any directory, but to make things simple for this Tour '''please make sure''' indeed to execute the <code> estudio </code> command from <code> YOURDIR </code>. (This will allow us to use relative rather than absolute names for some of the files involved.) 
+In general you can start EiffelStudio from any directory, but to make things simple for this Tour '''please make sure''' indeed to execute the <code>estudio</code> command from <code>YOURDIR</code>. (This will allow us to use relative rather than absolute names for some of the files involved.) 
 
 

documentation/current/eiffelstudio/eiffelstudio-how-tos/designing-project/altering-system/deleting-items.wiki

@@ -13,17 +13,5 @@
 [[Removing items from a view|Removing items from the view only]] }}
 
 
-* Pick-and-drop the item you want to remove in the '''Delete''' hole.  [[Image:16x16--general-delete-icon]]  For links, the associated Eiffel code will be removed from the class text. Clusters and classes will be deleted from disk! 
-
-{{warning|An action that deletes one or more files or directories cannot be undone! }}
-
-
-{{tip|Turn on '''Automatic backups'''. EiffelStudio will make a copy of each class file every time a compilation is done. }}
-
-
-{{seealso|<br/>
-[[Removing items from a view|Removing items from the view only]] }}
-
-
 
 

documentation/current/eiffelstudio/eiffelstudio-how-tos/designing-project/managing-links/using-link-tool.wiki

@@ -2,22 +2,24 @@
 [[Property:weight|3]]
 [[Property:uuid|2ab61f4c-fb5a-901c-f2b3-3ee680f48569]]
 If you do not want straight arrows, you can insert handles on them. It is recommended that you use the link tool to do this, because it inserts the handles so that the angles in the line are exactly 90 degrees.
-# To apply straight angles to a link, drop it in the '''Put handles on a link''' hole.  [[Image:diagram-force-right-angles-icon]]  
+* To apply straight angles to a link, drop it in the '''Put handles on a link''' hole.  [[Image:diagram-force-right-angles-icon]]  
-# The '''Link tool''' appears. Select the type of angle(s) you want for the link. 
+* The '''Link tool''' appears. Select the type of angle(s) you want for the link. 
+
 [[Image:link-tool]]  
+
 The combinations of handles you can apply to your link are: 
-#* Put handle left <br/>
+* Put handle left <br/>
- [[Image:link-tool-left]]  
+[[Image:link-tool-left]]  
-#* Put handle right <br/>
+* Put handle right <br/>
- [[Image:link-tool-right]]  
+[[Image:link-tool-right]]  
-#* Put two handles left <br/>
+* Put two handles left <br/>
- [[Image:link-tool-two-left]]  
+[[Image:link-tool-two-left]]  
-#* Put two handles right <br/>
+* Put two handles right <br/>
- [[Image:link-tool-two-right]]  
+[[Image:link-tool-two-right]]  
-#* Remove handles <br/>
+* Remove handles <br/>
- [[Image:link-tool-no-handles]]  
+[[Image:link-tool-no-handles]]  
 
-# Click '''OK''' when you are satisfied with the result, pressing '''Cancel''' will put the link back the way it was. 
+* Click '''OK''' when you are satisfied with the result, pressing '''Cancel''' will put the link back the way it was. 
 
 
 

documentation/current/eiffelstudio/eiffelstudio-how-tos/designing-project/managing-views/adding-view.wiki

@@ -1,9 +1,9 @@
 [[Property:title|Adding a view]]
 [[Property:weight|0]]
 [[Property:uuid|28444f17-3f20-72b5-dd5b-d812154a219f]]
-# To add a view of the current class or cluster, select the view you want to duplicate to the new one using the '''View''' combo box. <br/>
+* To add a view of the current class or cluster, select the view you want to duplicate to the new one using the '''View''' combo box. <br/>
- [[Image:diagram-defaultview]]  
+[[Image:diagram-defaultview]]  
-# Enter the name of the new view in the '''View''' combo box. <br/>
+* Enter the name of the new view in the '''View''' combo box. <br/>
- [[Image:diagram-myview]]  
+[[Image:diagram-myview]]  
-# Press enter. The view is now created.
+* Press enter. The view is now created.
 

documentation/current/eiffelstudio/eiffelstudio-how-tos/designing-project/managing-views/deleting-view.wiki

@@ -1,18 +1,9 @@
 [[Property:title|Deleting a view]]
 [[Property:weight|1]]
 [[Property:uuid|4e53dcce-8b05-823e-6911-ac85b226a511]]
-* To delete a view, select the view you want to remove using the '''View''' combo box. <br/>
- [[Image:diagram-defaultview]]  
-* Click the '''Delete current view''' button.  [[Image:16x16--general-delete-icon]]  <br/>
-
-*If you choose to confirm, the view has been deleted, and the "DEFAULT" view is selected.
-
-
-{{note| '''Note''': You cannot delete the view "DEFAULT". }}
-
 
 *To delete a view, select the view you want to remove using the '''View''' combo box. <br/>
- [[Image:diagram-defaultview]]  
+[[Image:diagram-defaultview]]  
 *Click the '''Delete current view''' button.  [[Image:16x16--general-delete-icon]]  <br/>
 
 *If you choose to confirm, the view has been deleted, and the "DEFAULT" view is selected.

documentation/current/eiffelstudio/eiffelstudio-how-tos/designing-project/modifying-display/changing-system-exploration-depth.wiki

@@ -2,10 +2,12 @@
 [[Property:weight|1]]
 [[Property:uuid|edb48c11-23fb-65d2-28c2-75cda5659dd8]]
 * If you want to change the context of the current cluster or class in the diagram, click the '''Select depth of relations''' button.  [[Image:diagram-depth-of-relations-icon]]  <br/>
-The '''Context''' dialog appears. The layout depends on whether the current context is one of a class or cluster. 
+* The '''Context''' dialog appears. The layout depends on whether the current context is one of a class or cluster. 
-** Context is a class: 
+* Context is a class: 
+
 [[Image:context-dialog-class]]  
 
-** Context is a cluster: 
+* Context is a cluster: 
+
 [[Image:context-dialog-cluster]]  
 

documentation/current/eiffelstudio/eiffelstudio-how-tos/designing-project/modifying-display/removing-items-view.wiki

@@ -6,9 +6,4 @@
 {{note|If you want to remove the item from the system, use the [[Deleting items|Delete]]  hole. }}
 
 
-* To remove an class, cluster, or link from the current view, use pick-and-drop to drop it in the '''Remove figure''' hole.  [[Image:general-reset-icon]] . To remove a link handle you can also the same technique 
-
-{{note|If you want to remove the item from the system, use the [[Deleting items|Delete]]  hole. }}
-
-
 

documentation/current/eiffelstudio/eiffelstudio-how-tos/generating-documentation/generating-multi-format-documentation.wiki

@@ -11,30 +11,36 @@ The first page of the Documentation Wizard lets you choose between the available
 
 {{tip|The nicest output is produced by the '''html-stylesheet''' format. }}
 
+
 Now the wizard asks you to select the clusters you want to produce documentation for:
 
 [[Image:doc-wizard-cluster-selection]]  
 
+
 In the next page you can specify indexing items on which HTML metatags will be based:
 
 [[Image:doc-wizard-indexing-selection]]  
 
 {{note|This page is only available for HTML documentation. }}
 
+
 You can then pick the formats you need among those available. For example, you might need a file containing the '''Cluster hierarchy''' of your system or, for each class, a file containing the '''Contracts''' of that class. At this point you can also decide to generate BON diagrams for the clusters selected in the previous page. 
 
 [[Image:doc-wizard-format-selection]]  
 
+
 If you have checked '''Cluster diagrams''' in the previous page, you will now be able to choose a view for each diagram that is going to be generated. You have the choice between an automatically arranged view and all of the [[Views|views ]] you may have manually arranged with the [[Diagram tool|Diagram Tool]] . 
 
 [[Image:doc-wizard-view-selection]]  
 
 {{note|Cluster diagrams are only available for HTML documentation. }}
 
+
 Here comes the last page; you can choose the directory where the documentation is going to be generated:
 
 [[Image:doc-wizard-path-selection]]  
 
+
 {{seealso|<br/>
 [[Generating XMI documentation|Generating XMI documentation]]  }}
 

documentation/current/eiffelstudio/eiffelstudio-how-tos/generating-documentation/generating-xmi-documentation.wiki

@@ -9,6 +9,7 @@ The first page of the wizard lets you select the clusters you want to produce do
 
 [[Image:xmi-wizard-cluster-selection]]  
 
+
 On the second and last page, you can choose the directory where the XML file is going to be generated:
 
 [[Image:doc-wizard-path-selection]]  

documentation/current/eiffelstudio/eiffelstudio-how-tos/running-and-debugging/profiling.wiki

@@ -27,29 +27,29 @@ It is also possible to dynamically start and stop the profiler in a program. To
 In the root feature:
 
 <code>
-	local
+        local
-		ps: PROFILING_SETTING
+            ps: PROFILING_SETTING
-			-- Other local variables if necessary.
+                -- Other local variables if necessary.
-	do
+        do
-		create ps.make
+            create ps.make
-		ps.stop_profiling
+            ps.stop_profiling
-			-- Real program execution.
+                -- Real program execution.
-		ps.start_profiling
+            ps.start_profiling
-	end</code>
+        end</code>
 
 
 And in the feature(s) that needs to be profiled:
 <code></code> 
 <code>
-	local
+        local
-		ps: PROFILING_SETTING
+            ps: PROFILING_SETTING
-			-- Other local variables if necessary.
+                -- Other local variables if necessary.
-	do
+        do
-		create ps.make
+            create ps.make
-		ps.start_profiling
+            ps.start_profiling
-			-- What needs to be profiled.
+                -- What needs to be profiled.
-		ps.stop_profiling
+            ps.stop_profiling
-	end</code>
+        end</code>
 
 
 {{note|Even if the profiler should only work in certain sections of code, the '''Profiling''' check box of the [[General Target Options|Projects Settings]]  dialog must be checked or the '''profile''' option must be set on certain clusters. }}

documentation/current/eiffelstudio/eiffelstudio-how-tos/running-and-debugging/using-debug-clauses.wiki

@@ -3,15 +3,15 @@
 [[Property:uuid|78e0273d-525e-a338-dfe4-d5fc27cd06d3]]
 Eiffel provides ways to add debug code to features to help during their debugging. You may think of it as the well-known C construct: <code></code> 
 
-<code>#ifdef MY_DEBUG_FLAG/* Debug code is here */ #endif</code>
+<code lang=c>#ifdef MY_DEBUG_FLAG/* Debug code is here */ #endif</code>
 
 
 The corresponding construct in Eiffel is provided by the debug keyword. It is possible to wrap code inside a debug clause like this:
 <code></code> 
 <code>
-	debug("MY_DEBUG_FLAG")
+            debug("MY_DEBUG_FLAG")
-		-- Debug code is here.
+                -- Debug code is here.
-	end</code>
+            end</code>
 
 
 It is then possible to enable or disable debug clauses globally.