diff --git a/documentation/current/eiffelstudio/eiffelstudio-guided-tour/browsing-features.wiki b/documentation/current/eiffelstudio/eiffelstudio-guided-tour/browsing-features.wiki
index ed6859c6..a96185ec 100644
--- a/documentation/current/eiffelstudio/eiffelstudio-guided-tour/browsing-features.wiki
+++ b/documentation/current/eiffelstudio/eiffelstudio-guided-tour/browsing-features.wiki
@@ -6,11 +6,11 @@ Let us get back to EiffelStudio. We won't need a browser any more for this Tour,
Before studying the documentation generation we saw how to display properties of classes. It's also interesting to explore the properties of features. Let's look at this now, through the Feature View.
-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.
+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.
-If the Features Tool is not visible, bring it back by clicking the Features button on the top toolbar, used earlier to remove it.
+If the Features Tool is not visible, bring it back by clicking the Features button on the top toolbar, used earlier to remove it.
-(Another way is through the menu entry View --> Tools --> Features ).
+(Another way is through the menu entry View --> Tools --> Features ).
==Targeting to a feature==
@@ -18,11 +18,11 @@ The list of features, organized by feature clauses, appears on the left:
[[Image:index-51]]
-The class only has a few immediate features because most of its interesting features are inherited. Make sure the Editing 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 Editing Tool's current target, and scrolls the text to its declaration:
+The class only has a few immediate features because most of its interesting features are inherited. Make sure the Editing 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 Editing Tool's current target, and scrolls the text to its declaration:
[[Image:index-52]]
-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 .
+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==
@@ -30,45 +30,45 @@ Now let's look at the feature views. Click the Feature Tab at the bottom of the
This brings up basic information on the selected feature in the Context Tool.
-The bottom Context Tool shows one of the Feature views, by default Flat . 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 .
+The bottom Context Tool shows one of the Feature views, by default Flat. 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 Feature View toolbar
+Flat is just one of the available Feature Views, shown by the buttons on the Feature View toolbar
- Text gives the feature text, fully clickable.
+Text gives the feature text, fully clickable.
Flat is Callers . Try it now by clicking the corresponding button (the following figure and the next only show the Context Tool, where the views appear):
+Next to Flat is Callers. Try it now by clicking the corresponding button (the following figure and the next only show the Context Tool, where the views appear):
[[Image:index-55]]
-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 see that:
-* The version from LIST is called in LIST itself by the function is_equal .
-* The version from LIST's descendant ARRAYED_CIRCULAR is not called directly in this system, although it '''could''' be called through dynamic binding (on an entity declared of type LIST but dynamically attached to an instance of ARRAYED_CIRCULAR ).
-* About 60% down, forth from ARRAYED_LIST , a version in another descendant of LIST , is called by two routines of ARRAYED_CIRCULAR , one routine of ARRAYED_LIST , and two routines of MULTI_ARRAY_LIST .
-* Also note, in the following entry, that after renaming forth is called back in the descendant ARRAYED_STACK .
+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 see that:
+* The version from LIST is called in LIST itself by the function is_equal.
+* The version from LIST's descendant ARRAYED_CIRCULAR is not called directly in this system, although it '''could''' be called through dynamic binding (on an entity declared of type LIST but dynamically attached to an instance of ARRAYED_CIRCULAR).
+* About 60% down, forth from ARRAYED_LIST, a version in another descendant of LIST, is called by two routines of ARRAYED_CIRCULAR, one routine of ARRAYED_LIST, and two routines of MULTI_ARRAY_LIST.
+* Also note, in the following entry, that after renaming forth is called back in the descendant ARRAYED_STACK.
The following five view buttons are similar except that they let you precise what kind of callers you are looking for, or what is being called by the currently selected feature.
==What happens to my feature through the inheritance hierarchy?==
-After the caller/callee views, the next view button is Implementers.
+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 (from version) signals the version applicable to the current class, here LIST .
+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.
+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 .
+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.
+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.
+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.
+The next button, Descendant versions, similarly tells you all that happens to a feature in the descendants of the current class.
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.
+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.
Project menu, but the easiest for the moment is to use the compilation button in the Project toolbar, the lower toolbar in the Development Window. Click this button. You haven't changed anything in the project since it was compiled (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.
+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, the lower toolbar in the Development Window. Click this button. You haven't changed anything in the project since it was compiled (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.
root_cluster and click class PARENT to retarget the Development Window to it.
+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 Cluster tree on the left, 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:
[[Image:index-66]]
-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:
+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 more added text")
io.new_line
-They are very similar to the current first two lines of the routine, so you can just use copy-paste: select the first 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, and change the string to THIS IS SOME MORE ADDED TEXT so that the result will look like what's shown on the next figure. This is all there is to change; the second line remains untouched. 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!
+They are very similar to the current first two lines of the routine, so you can just use copy-paste: select the first 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, and change the string to THIS IS SOME MORE ADDED TEXT so that the result will look like what's shown on the next figure. This is all there is to change; the second line remains untouched. 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!
[[Image:index-67]]
-Now save your changes; you may indifferently use CTRL- S , the Save entry from the Edit menu, or the Save button highlighted 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.)
+Now save your changes; you may indifferently use CTRL- S, the Save entry from the Edit menu, or the Save button highlighted 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.)
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.
+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.
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 .
+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. }}
+{{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 .
+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 .
+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 Edit --> Advanced --> Indent selection . 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 indent a sequence of lines, select the lines, then use Edit --> Advanced --> Indent selection. 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 or CTRL- K . Conversely, CTRL-Shift- K will uncomment. Also in the Edit --> Advanced menu are "set to upper case", with the keyboard shortcut CTRL- U , and to lower case, CTRL-Shift- U .
+To '''comment out''' a sequence of lines, select them and use Edit --> Advanced --> Comment or CTRL- K. Conversely, CTRL-Shift- K will uncomment. Also in the Edit --> Advanced menu are "set to upper case", with the keyboard shortcut CTRL- U, and to lower case, CTRL-Shift- U.
-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.
+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.
Edit --> Find menu entry.
+To start a search, make sure the Search Tool is active by clicking the Search button in the top toolbar (this one we'll let you find) or using the Edit --> Find menu entry.
{{note|that although we are studying Search as part of the Editor, this function also applies to any textual form displayed in the Context Tool; make sure to start a Search from the tool that you want to search.'' }}
@@ -76,29 +76,29 @@ The Search Tool presents a number of self-explanatory options:
[[Image:index-69]]
-You can enter a term to replace your search term in the Replace with box.
+You can enter a term to replace your search term in the Replace with box.
Having filled the two fields, you can elect to replace the last found occurrence, or all occurrences at once.
-The Search for field has an associated drop-down list, so that you can reuse a recently entered search string without retyping it.
+The Search for field has an associated drop-down list, so that you can reuse a recently entered search string without retyping it.
Tools --> Preferences --> Editor you can easily disable any facility that you don't like. The behavior described here is the default.
+Particularly interesting are the editor's '''automatic completion''' facilities. Well, particularly interesting for most people: maybe you like your editor to do the grunt work for you, or maybe you don't. In the latter case -- if you prefer to be in control of all the details -- don't worry: through Tools --> Preferences --> Editor you can easily disable any facility that you don't like. The behavior described here is the default.
The EiffelStudio Editor knows about Eiffel syntax and will recognize syntactic elements as you type them. It will color them according to standard conventions: basic elements in black, keywords in blue, comments in dark red. You can change these conventions through Preferences.
-If you start typing a control structure through its opening keyword, such as if , or from for a loop, the editor will automatically display the structure of the whole construct. Here for example is the result if you type the from followed by Return/Enter at the beginning of our example routine:
+If you start typing a control structure through its opening keyword, such as if, or from for a loop, the editor will automatically display the structure of the whole construct. Here for example is the result if you type the from followed by Return/Enter at the beginning of our example routine:
[[Image:index-71]]
-This has produced the structure of an Eiffel loop: from ... until ... loop ... end . You can then fill in the blanks with the appropriate expression and instructions. The generated lines start with the appropriate number of Tab characters to support the standard Eiffel indenting conventions. If you want a more compact style, follow the from with a space rather than Return. Typing if followed by Return or a space will similarly produce the outline of a conditional instruction.
+This has produced the structure of an Eiffel loop: from ... until ... loop ... end. You can then fill in the blanks with the appropriate expression and instructions. The generated lines start with the appropriate number of Tab characters to support the standard Eiffel indenting conventions. If you want a more compact style, follow the from with a space rather than Return. Typing if followed by Return or a space will similarly produce the outline of a conditional instruction.
-To start a routine, type the routine name followed by the keyword is and a Return. The editor generates the basic structure of a routine text:
+To start a routine, type the routine name followed by the keyword is and a Return. The editor generates the basic structure of a routine text:
[[Image:index-72]]
-This prompts you to enter the header comment (no self-respecting Eiffel developer even thinks of writing a feature without a header comment). At the end of the header comment, type Return if the header comment continues, otherwise type a down arrow to continue with the indentation for the beginning of the routine, with one of the keywords require , local , do , external , once . Once you type do , followed by a Return or space, the completion mechanism will insert the appropriate end , but other than that it doesn't try to produce an entire routine structure because there are too many syntactical choices (precondition or not, postcondition or not, locals or not etc.).
+This prompts you to enter the header comment (no self-respecting Eiffel developer even thinks of writing a feature without a header comment). At the end of the header comment, type Return if the header comment continues, otherwise type a down arrow to continue with the indentation for the beginning of the routine, with one of the keywords require, local, do, external, once. Once you type do, followed by a Return or space, the completion mechanism will insert the appropriate end, but other than that it doesn't try to produce an entire routine structure because there are too many syntactical choices (precondition or not, postcondition or not, locals or not etc.).
Also interesting is '''feature completion''', using the '''CTRL-SPACE''' key. It works at two levels:
* You can type the beginning of the name of a feature of the current class, then CTRL-SPACE to get possible completions.
@@ -106,7 +106,7 @@ Also interesting is '''feature completion''', using the '''CTRL-SPACE''' key. It
In both cases, if more than one completion is possible, you will get a menu of the possibilities. You can scroll through it with the up and down arrow keys, or the mouse, and select one through Enter or double-click. You can also or give up through the Escape key.
-Here for example is the menu you will see in the body of our example routine if you type io . followed by CTRL-SPACE, where io is the feature, coming from class ANY , that provides access to standard input and output facilities:
+Here for example is the menu you will see in the body of our example routine if you type io . followed by CTRL-SPACE, where io is the feature, coming from class ANY, that provides access to standard input and output facilities:
[[Image:index-73]]
@@ -118,21 +118,21 @@ The following properties enhance the convenience of the completion mechanisms:
The combination of these facilities means that you can often obtain what you want simply by typing CTRL-SPACE repeatedly.
Also note the following properties of automatic feature completion:
-* The mechanism will only work for queries that were present at the time of the last successful compilation. So if you add an attribute, say attr , to the current class, and do not recompile, typing a -CTRL-SPACE will not display attr . To make sure that it's included in completion proposals, save and recompile. (Remember, incremental compilation is fast in EiffelStudio, so there is nothing wrong in compiling early and often.) The same rule holds for features of other classes, those that will appear in proposed completions after a period.
+* The mechanism will only work for queries that were present at the time of the last successful compilation. So if you add an attribute, say attr, to the current class, and do not recompile, typing a -CTRL-SPACE will not display attr. To make sure that it's included in completion proposals, save and recompile. (Remember, incremental compilation is fast in EiffelStudio, so there is nothing wrong in compiling early and often.) The same rule holds for features of other classes, those that will appear in proposed completions after a period.
* Automatic completion is applicable to features, not local entities or formal arguments.
-* The features proposed for automatic completion include all features of the class: those declared in the class itself, or immediate features, and those inherited from proper ancestors, direct or indirect, with one exception: by default the list will not include features from the universal class ANY , which serves as ancestor to all classes and provides many features for comparison, copying, input-output, reflection etc. Including ANY's features would clutter all menus with too many features. So for example typing i followed by CTRL-SPACE will not suggest io among the possible completions. You can change this policy through Preferences. The policy does not apply to remote feature completion for an entity x declared of type ANY : typing CTRL-SPACE after x . will produce the list of ANY 's features.
+* The features proposed for automatic completion include all features of the class: those declared in the class itself, or immediate features, and those inherited from proper ancestors, direct or indirect, with one exception: by default the list will not include features from the universal class ANY, which serves as ancestor to all classes and provides many features for comparison, copying, input-output, reflection etc. Including ANY's features would clutter all menus with too many features. So for example typing i followed by CTRL-SPACE will not suggest io among the possible completions. You can change this policy through Preferences. The policy does not apply to remote feature completion for an entity x declared of type ANY : typing CTRL-SPACE after x . will produce the list of ANY 's features.
==Using your own editor==
You may have a favorite editor and prefer to use it, at least in some cases. The EiffelStudio incremental compilation mechanism, to be studied shortly, recognizes that files have been modified outside of EiffelStudio (by checking their time stamps) and will without any fuss take their modified versions into account.
-You can also call an outside editor on a class from within EiffelStudio. Just use File --> External editor or the corresponding button in the top toolbar.
+You can also call an outside editor on a class from within EiffelStudio. Just use File --> External editor or the corresponding button in the top toolbar.
-This will call the editor of your choice. The default is Notepad on Windows and Vi on Unix and Linux. You can easily change this to any editor by entering the desired editor command in Tools --> Preferences --> Global Preferences . In this command text you can use the two special notations $target and $line ; when EiffelStudio calls the selected command, it will replace any occurrence of $target by the name of the file where the current class resides, and $line by the line number at which the Editing Tool is currently scrolled. If you include one or both of these markers at the appropriate argument positions for the command, this will enable you -- assuming the editor supports the appropriate options -- to make sure it starts at exactly the right place. For example the default editor command under Unix is
+This will call the editor of your choice. The default is Notepad on Windows and Vi on Unix and Linux. You can easily change this to any editor by entering the desired editor command in Tools --> Preferences --> Global Preferences. In this command text you can use the two special notations $target and $line ; when EiffelStudio calls the selected command, it will replace any occurrence of $target by the name of the file where the current class resides, and $line by the line number at which the Editing Tool is currently scrolled. If you include one or both of these markers at the appropriate argument positions for the command, this will enable you -- assuming the editor supports the appropriate options -- to make sure it starts at exactly the right place. For example the default editor command under Unix is
vi +$line $target
-meaning: start the Vi editor on the $target file, initially positioned at line $line (the + line_number command-line option of Vi directs it to start at line line_number ).
+meaning: start the Vi editor on the $target file, initially positioned at line $line (the + line_number command-line option of Vi directs it to start at line line_number ).
If you start an external editor on a class, then exit the editor after possibly making changes, EiffelStudio will immediately update the class text in the Editing Tool. More generally, note that EiffelStudio will detect changes made separately on the same class, and warn you of possible conflicts.
diff --git a/documentation/current/eiffelstudio/eiffelstudio-guided-tour/retargeting-through-pick-and-drop.wiki b/documentation/current/eiffelstudio/eiffelstudio-guided-tour/retargeting-through-pick-and-drop.wiki
index d3fe6d37..7f494634 100644
--- a/documentation/current/eiffelstudio/eiffelstudio-guided-tour/retargeting-through-pick-and-drop.wiki
+++ b/documentation/current/eiffelstudio/eiffelstudio-guided-tour/retargeting-through-pick-and-drop.wiki
@@ -6,9 +6,9 @@ You now know quite a few ways of re-targeting a Development Window to a "develop
forth of class LIST . The next figure shows the whole window; it should be exactly what you see as a result of the last operations. We'll use the Ancestor versions view of the Feature Tab.
+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 be exactly what you see as a result of the last operations. We'll use the Ancestor 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, click the corresponding buttons as detailed [[7 CLASS VIEWS|here]] ); target the tool to class LIST ; target further to its feature forth by clicking that feature name in the Feature tree; make sure both the top-right Editing Tool and the bottom-right Context Tool are visible; in the Context Tool, select the Feature Tab and its Descendant versions format.
+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, click the corresponding buttons as detailed [[7 CLASS VIEWS|here]] ); target the tool to class LIST ; target further to its feature forth by clicking that feature name in the Feature tree; make sure both the top-right Editing Tool and the bottom-right Context Tool are visible; in the Context Tool, select the Feature Tab and its Descendant versions format.
[[Image:index-60]]
@@ -17,22 +17,23 @@ In the Context Tool near the bottom right, there is an entry that reads
ARRAYED_CIRCULAR forth
-referring to the version of feature forth in class ARRAYED_CIRCULAR . 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 ARRAYED_CIRCULAR in the Class field at the top of the window, and the feature name forth in the adjacent Feature field. But this is too much work; 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.
+referring to the version of feature forth in class ARRAYED_CIRCULAR. 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 ARRAYED_CIRCULAR in the Class field at the top of the window, and the feature name forth in the adjacent Feature field. But this is too much work; 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 Development Window targeted to forth from ARRAYED_CIRCULAR . But you don't necessarily want a new window. Instead you can use Pick-and-Drop to retarget the current window.
+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 Development Window targeted to forth from ARRAYED_CIRCULAR. But you don't necessarily want a new window. 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 ARRAYED_CIRCULAR . Right-click, that is to say click the rightmost mouse button, and '''release the button immediately'''. That's right: you use a simple click, and do '''not''' maintain the button down.
+Here is how it works. Position the cursor on the desired feature reference: the word forth in the line forth ARRAYED_CIRCULAR. Right-click, that is to say click the rightmost mouse button, and '''release the button immediately'''. That's right: you use a simple click, and do '''not''' maintain the button down.
Now move the mouse a trifle, without pressing any button :
forth . Now you can drop it at any appropriate place to retarget the corresponding tool. In fact you can drop it right where it is, in the Context Tool of the current Development tool. To drop, just '''right-click''' again. (That is to say, as before, press the rightmost mouse button and release it immediately.) This achieves a "drop", and retargets the Development Window to the chosen feature, forth from ARRAYED_CIRCULAR . The retargeting affects both the Editing Tool and the Context Tool (assuming the Link Content View option is selected on the toolbar, see below "Isolating the context" for more information), which keeps its current view ( Descendant versions in the Feature Tab). We'll see shortly how to give them separate targets if that's preferred.
+The display reflects that you have " picked " the feature forth. Now you can drop it at any appropriate place to retarget the corresponding tool. In fact you can drop it right where it is, in the Context Tool of the current Development tool. To drop, just '''right-click''' again. (That is to say, as before, press the rightmost mouse button and release it immediately.) This achieves a "drop", and retargets the Development Window to the chosen feature, forth from ARRAYED_CIRCULAR. The retargeting affects both the Editing Tool and the Context Tool (assuming the Link Content View option is selected on the toolbar, see below "Isolating the context" for more information), which keeps its current view ( Descendant versions in the Feature Tab). We'll see shortly how to give them separate targets if that's preferred.
[[Image:index-62]]
==How Pick-and-Drop works==
+
The Pick-and-Drop mechanism is very simple. It consists of three steps:
* '''Pick''' step: find the development object you want to pick, right-click it, release the mouse button.
* '''Move''' step: move the mouse to the desired drop point, without pressing any button.
@@ -48,9 +49,9 @@ The Pick-and-Drop mechanism relies on the metaphor of '''pebbles and holes'''. W
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.
-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.
+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.
-In the Pick-and-Drop example -- for forth of ARRAYED_CIRCULAR -- you did not have to go to a new target: the current window was a valid drop target, so you just dropped right away. In such a case you don't even have to move the mouse; Pick-and-Drop is just a matter of two right-clicks.
+In the Pick-and-Drop example -- for forth of ARRAYED_CIRCULAR -- you did not have to go to a new target: the current window was a valid drop target, so you just dropped right away. In such a case you don't even have to move the mouse; Pick-and-Drop is just a matter of two right-clicks.
This is similar to a '''double-click''', a commonly used interaction technique, but without the stress of the usual double-click, which requires you to wait no more than a specified time -- typically half a second or so -- between the two clicks. With Pick-and-Drop the effect is the same whether the second click follows the first after one tenth of a second or two days.
-File --> New window
+File --> New window
(unless you already have a second Development Window open, in which case you can simply reuse it). Make sure the two Development Window do not overlap too much, so that you can see enough of each. In the first Development Window, pick a class (right-click it). Move the mouse to the Editing Tool of the second Development Tool. Drop the class by right-clicking again. The tool retargets itself to the chosen class.
@@ -103,25 +104,28 @@ To change the behavior, choose the menu entry
View --> Link context tool
-After this, the entry will change to View --> Unlink context tool , so that you can later revert to isolated behavior. Under isolation behavior, try pick-and-dropping a class or feature into the top Editing Tool; then pick-and-drop a class or feature into the bottom Context Tool. You will notice that each of these operations retargets the affected tool, but not the other.
+After this, the entry will change to
+
+View --> Unlink context tool
+so that you can later revert to isolated behavior. Under isolation behavior, try pick-and-dropping a class or feature into the top Editing Tool; then pick-and-drop a class or feature into the bottom Context Tool. You will notice that each of these operations retargets the affected tool, but not the other.
Link/Isolate button of the top toolbar. This button is not present by default on the toolbar, so this is a good opportunity to take a quick look at the user interface customization mechanism, which you can use later to tailor the interface to the exact form you need. Select
+If you will often alternate between the linked and isolated behaviors, you can use the Link/Isolate button of the top toolbar. This button is not present by default on the toolbar, so this is a good opportunity to take a quick look at the user interface customization mechanism, which you can use later to tailor the interface to the exact form you need. Select
View --> Toolbars --> Customize standard toolbar
-(The adjacent entry is toolbar project Customize which provides complementary capabilities under a similar form.) You see a list of available buttons:
+(The adjacent entry is toolbar project Customize which provides complementary capabilities under a similar form.) You see a list of available buttons:
[[Image:index-63]]
-The icons in the list on the right are currently displayed in the toolbar, but not those on the left. Among the latter you see (fourth from the bottom on the left-side list) Link or not the context tool to other components . Select it by clicking; this makes the -> Add button active. Click this button to move the Link/Isolate icon to the list of displayed icons. It becomes the first item of the list, which is fine for the moment. (Later on you can change the order of buttons in the toolbar if you like, by using the Up and Down buttons.) Click OK . The toolbar of your development tool has a new button which you can now use to switch, for the enclosing Development Window, between the isolated and linked behaviors of the Context Tool.
+The icons in the list on the right are currently displayed in the toolbar, but not those on the left. Among the latter you see (fourth from the bottom on the left-side list) Link or not the context tool to other components. Select it by clicking; this makes the ->Add button active. Click this button to move the Link/Isolate icon to the list of displayed icons. It becomes the first item of the list, which is fine for the moment. (Later on you can change the order of buttons in the toolbar if you like, by using the Up and Down buttons.) Click OK. The toolbar of your development tool has a new button which you can now use to switch, for the enclosing Development Window, between the isolated and linked behaviors of the Context Tool.
Class Tab, and pick-and-dropping a feature switches to the Feature Tab.
-* The view displayed in each case -- for example Ancestors for the Class Tab and Flat for the Feature Tab -- is default view for the corresponding Tab.
+* In most cases, pick-and-dropping a class to the Context switches the view to the Class Tab, and pick-and-dropping a feature switches to the Feature Tab.
+* The view displayed in each case -- for example Ancestors for the Class Tab and Flat for the Feature Tab -- is default view for the corresponding Tab.
==The many paths to retargeting==