[[Category:EiffelStudio]]
[[Category:Releases]]

== Overview ==
The page highlights the list of bugs that must be fixed prior releasing EiffelStudio version '''Y''' (previous release is called '''X''').

== Disclaimer ==
This list is maintained by Eiffel Software employees only. Any external users modifying the page will most likely see their changes removed. If you have a show stopper bug please add it to the User Section below. We are aware of all of your submitted bugs but we have to prioritize and fix all those that can be fixed before the end of this release cycle, which is imminent.

== What is a "Critical Bug" ==
A bug is critical if it is reproducible and satisfies one of the following conditions:

# Something that used to work in version '''X''' and that does not work in '''Y'''.
# New functionality that is broken in '''Y'''.
# A crash that was not present in '''X'''.

== Bug List and Links ==

== EiffelStudio User Interface ==

=== Code Tools ===

* bug#12392: PnD does not open a new document tab when using prefixes
* bug#12372: Tools disappear after running debugger
* bug#12535: Consider changing order of tools in Show List popup
* bug#12510: Control+Tab inactivated for awhile after Control+Tab with scroll
* <del>bug#12854</del>: Typing name of class not in system into Feature Relation title bar causes crash
* bug#12155: Precompiles included in Clusters possibilities in Clusters field

=== Debugger ===
* bug#12606: Stepping with Auto Expressions in sample graphical app causes crash (part about static externals in precompile is fixed)
* bug#12534: Clicking on Open Exception Dialog hangs estudio and window system
* bug#12741: Changing arguments for profile in Debug Options window leads to crash
* bug#12907: Debugger scroll area with profiles not wide enough to see all text initially
* bug#12906: Debugger Control+Enter brings up menu of existing env variables in wrong location

=== Docking ===
* bug#12330: Three simple docking moves causes crash
* bug#12756: Undocking toolbar and moving to right side of main window causes crash
* bug#12738: Resetting tools layout after auto-hiding all tools causes crash
* bug#12612: Moving Project toolbar to top row and clicking Toolbar Options caused crash
* bug#12427: Switching to Force Debugger Mode and back crashes if auto-hidden tools
* bug#12065: Creating narrow window via docking causes estudio crash or hang
* bug#12119: Configuration with multiple windows not restored correctly on restart
* bug#12927: Sequence of layout saves/opens makes Force Debug Mode indicator wrong
* bug#12542: Multiple problems with undocked toolbars (may all be fixed)
* bug#12873: Undocked toolbar position changes after saving layout and restoring
* bug#12558: Closing undocked Project toolbar while customizing it makes reshow fail
* bug#12213: Undocked window title not visible on Solaris SPARC with CDE when focus elsewhere
* bug#12340: Switching between forced/normal debugger mode makes undocked Objects window tiny
* bug#12375: Closing undocked window and reshowing displays it in different location
* bug#12549: Double-clicking on title bar of undocked toolbar activates button below click
* bug#12623: Moving tool to another zone and then selecting it from Show List popup causes crash
* bug#12550: Customizing undocked toolbar with one row splits it into two rows
* bug#12635: Address toolbar not displayed correctly when docked vertically
* bug#12624: Multiple clicks on Show List button brings up multiple popup windows

=== Editor ===
* bug#12322: Exception in {SMART_TEXT}.item
* bug#12940: Selecting View/Flat in editor for class not in system shows flat view of other class

=== Metrics ===

=== Wizards ===
=== Toolbars ===
* <del>bug#12898</del>: Right-clicking on Start button brings up button display/customize toolbar menu
* <del>bug#12811</del>: Customizing toolbar and reordering via pick and drop does not position items correctly
* bug#12532: Part of tabs not visible after initial compile or toolbar move
* <del>bug#12874</del>: View/Toolbars menu not updated when show/hide toolbar via right-click menu
* bug#12536: Cannot distinguish pushed-in buttons from other buttons in Class tool

=== Context menus ===
* <del>bug#12625</del>: Control-right click opens new Editor tab but also brings up context menu
* bug#12621: Context View menu does not work correctly when Editor tab targeted to cluster

== Eiffel Compiler ==
* bug#12282: Expression with INTEGER_32 times REAL_64 interpreted as INTEGER_32 by full class checker
* bug#12911: Interrupting compilation in degree 6 and then compiling causes crash
* bug#12603: Compiling class with external routine crashes estudio (Solaris x86)
* bug#12129: System compiled with dynamic runtime gets link warnings and won't run
* bug#12782: Changing generic class to non-generic and recompiling crashes in degree 1
* bug#12776: Generic constraint which renames attribute to infix feature crashes compiler
* bug#12775: Generic constraint with Rename that lists to Rename_pair elements crashes compiler

== Libraries ==

=== EiffelVision2 ===

== Installation ==

== User Section ==
{{note| External users of Eiffel Software may place their bug report ID's and their description here. There is no guarantee that these bugs will be seen to prior to the release of 6.0. And please, only critical bugs that prevent you from continuing your work. }}

The Wiki automatically links bugs in the using the format bug(pound sign #)id, e.g. bug#0000.

* bug#12902: WEL_ERROR Dialog on starting debugger (resource leak?)
* bug#12762: Ctrl+right-click sets focus to address bar (This doesn't prevent me from doing my work, but it's a regression from 5.7.)
* bug#12888: Editors do not repaint when debugger starts (This doesn't prevent me from doing my work, but it's a regression from 5.7.)
* bug#12920: EiffelBuild: Holding digit key does not work (This doesn't prevent me from doing my work, but it's a regression from 5.7.)

Critical Bug Fixes

2007-05-31T22:48:06Z

King: /* Toolbars */

Context Menu modes

2007-05-07T21:34:40Z

King:

=Context Menu Mode Switch=

Currently, EiffelStudio has two pebble transport mechanism for performing command shortcuts within the IDE, these modes are Pick and Drop and new for EiffelStudio 6.0, Contextual Menus. They are closely related in the sense that they both provide a mechanism for transporting a pebble source to a destination target.

Previous EiffelStudio versions have only included the Pick and Drop pebble transport mechanism but this is not a standard way of performing tasks and can be somewhat alien to new users. The Contextual Menus have been added as a way for EiffelStudio to entice new users by providing a more recognisable approach to accessing the facilities that the IDE provides.

=Setting the default transport mode=

In the EiffelStudio preferences window, there is a preference for deciding what pebble transport mechanism should be the default. This is located in General /Pnd mode where True is for pick and drop mode and False is to use Contextual Menus as the default mode, this preference is subject to change.

=Activating a pebble transportation=

EiffelStudio has many potential pebble sources, the most prevalent ones being Class pebbles and Feature pebble. A simple right click on a pebble will activate the transport mechanism and a command to be performed on that pebble can be achieved either by dropping the pebble on to a highlighted source (if in Pick and Drop mode) or selected via a Contextual Menu item.

=Switching from one mode to the other=

Even though one mechanism is default, the use of the shift key whilst activating the transport mechanism with a right mouse click can be used to switch from the default mechanism to the other.

=Using the mechanism with EiffelVision 2=

This mechanism is built in to Vision2 and use of the original pick and drop can be updated to use the Context Menu mechanism, this is demonstrated with the following code segments.

<code>[eiffel,n]

pebble_source_widget.set_pebble ("STRING pebble")

pebble_source_widget.set_configurable_target_menu_mode;
pebble_source_widget.set_configurable_target_menu_handler (agent target_menu_handler)

pebble_target_widget.drop_actions.extend (agent print)
pebble_target_widget.set_target_data_function (agent target_data_function)

target_menu_handler (
a_menu: EV_MENU;
a_target_list: ARRAYED_LIST [EV_PND_TARGET_DATA];
a_source: EV_PICK_AND_DROPABLE;
a_pebble: ANY
)

do
-- Within this feature you can manipulate `a_menu' to add custom menu items
-- `a_menu' must be populated by this routine, if `a_menu' is untouched,
-- a regular pick and drop transport will initiate.
-- a_target_list is an array of all the potential targets for `a_pebble', the
-- meta data includes target, menu text and pixmap (if applicable), this can be
-- customized for each target with {EV_PICK_AND_DROPABLE}.set_target_data_function.
-- `a_source' is the pebble source widget.
-- `a_pebble' is the pebble in question.

a_menu.extend (create {EV_MENU_ITEM}.make_with_text (a_target_list.first.name))
end

pebble_target_widget.set_target_data_function (agent target_data_function)

target_data_function (a_pebble: ANY): EV_PND_TARGET_DATA
local
l_string: STRING
do
l_string ?= a_pebble
if l_string /= Void
create Result
Result.set_name ("Print the string " + a_pebble)
end
end

</code>

Context Menu modes

2007-05-07T21:15:25Z

King:

=Context Menu Mode Switch=

Currently, EiffelStudio has two pebble transport mechanism for performing command shortcuts within the IDE, these modes are Pick and Drop and new for EiffelStudio 6.0, Contextual Menus. They are closely related in the sense that they both provide a mechanism for transporting a pebble source to a destination target.

Previous EiffelStudio versions have only included the Pick and Drop pebble transport mechanism but this is not a standard way of performing tasks and can be somewhat alien to new users. The Contextual Menus have been added as a way for EiffelStudio to entice new users by providing a more recognisable approach to accessing the facilities that the IDE provides.

=Setting the default transport mode=

In the EiffelStudio preferences window, there is a preference for deciding what pebble transport mechanism should be the default. This is located in General /Pnd mode where True is for pick and drop mode and False is to use Contextual Menus as the default mode, this preference is subject to change.

=Activating a pebble transportation=

EiffelStudio has many potential pebble sources, the most prevalent ones being Class pebbles and Feature pebble. A simple right click on a pebble will activate the transport mechanism and a command to be performed on that pebble can be achieved either by dropping the pebble on to a highlighted source (if in Pick and Drop mode) or selected via a Contextual Menu item.

=Switching from one mode to the other=

Even though one mechanism is default, the use of the shift key whilst activating the transport mechanism with a right mouse click can be used to switch from the default mechanism to the other.

=Using the mechanism with EiffelVision 2=

This mechanism is built in to Vision2 and use of the original pick and drop can be updated to use the Context Menu mechanism with the following code (where pebble_source_widget is the source of the pebble)

<code>[eiffel,n]

pebble_source_widget.set_configurable_target_menu_mode;
pebble_source_widget.set_configurable_target_menu_handler (agent target_menu_handler)

target_menu_handler (
a_menu: EV_MENU;
a_target_list: ARRAYED_LIST [EV_PND_TARGET_DATA];
a_source: EV_PICK_AND_DROPABLE;
a_pebble: ANY
)

do
-- Within this feature you can manipulate `a_menu' to add custom menu items
-- `a_menu' must be populated by this routine, if `a_menu' is untouched,
-- a regular pick and drop transport will initiate.
-- a_target_list is an array of all the potential targets for `a_pebble', the
-- meta data includes target, menu text and pixmap (if applicable), this can be
-- customized for each target with {EV_PICK_AND_DROPABLE}.set_target_data_function.
-- `a_source' is the pebble source widget.
-- `a_pebble' is the pebble in question.
end

</code>

2007-04-17T22:16:21Z

King: /* Initial Points encountered during implementation */

[[Category:Context_Menu]]
== Initial Points encountered during implementation ==

* I'm adding m_show to INTERFACE_NAMES for the english text "Show", this will need translating to the various dialects.
* If Context Menu is shown and a menu item is selected, on Windows at least the keyboard then ceases to function. It works fine if the 'Pick' option is used from the context menu. It may be possible that the context menu leaves the editor in an invalid state.
* The command structure in Studio would benefit from being reorganized in a uniform way so that commands may be retrieved without having intimate knowledge of the data structures in Studio. This could also benefit a plugin mechanism should we go down that route.
* There is currently no interface for class 'move' refactoring method.
* Selection behavior needs to be consistent in Studio editor. If I select text in the Studio editor, then right click over a class, I expect the selected text to be the 'context', not the class. This requires a change in the pebble retrieval mechanism in the editor when contextual pick and drop mode is activated.
* I reimplemented the context menu mechanism to allow for Void pebbles (such as when right clicking on the editor background), the original idea of implemented a VOID_STONE object was not feasible as most drop action agents take a STONE object and this would mean placing a veto agent on every drop action to check if the pebble did not conform to VOID_STONE before allowing transport. Now when a Void pebble is passed to the contextual menu agent, I create the default editor menu within {EB_CLICKABLE_EDITOR}.context_menu_handler.
* The context menu factory has to be placed in the class where the source is due to the use of plain EV_* objects for the pebble, this means we have no idea of where the source originates from as their is no relationship between PND source and contextual menu handler. This problem was also the reason why the mechanism could not be automated due to no direct relationship between the PND targets and the actual commands without a complete design overhaul.

== Current Status ==

I've implemented the contextual pick and drop mechanism for EB_CLICKABLE_EDITOR (code not yet committed). I had to change a number of command classes to make them easier to access as although most have a specific type for the command, such as EB_EDITOR_PASTE_COMMAND, there were some commands that were using generic classes, for cut and copy. So I reimplemented these to use inheritance rather that client manipulation of EB_ON_SELECTION_COMMAND

2007-04-09T19:54:25Z

King:

[[Category:Context Menu]]

== Initial Mechanism ==

The mechanism for providing contextual menus in EiffelStudio will come from a modification of the Pick and Drop mechanism. By doing this it will give a lot more control when it comes to integrating the technology as we need to give full access to the existing Pick and Drop mechanism via the Context Menu. This is because at first not every potential pebble 'drop' will be possible via a menu entry due to the hundreds of possibilities/commands Eiffel Studio currently has and using the Context menu may or may not be the quickest way to achieve this for an advanced user. EiffelVision currently does not expose the pick and drop mechanism so that it may be performed manually so having everything set up via Vision2 and passed to a handler seems to be the best approach for now as it involves the least amount of work and testing for providing the mechanism. Future work could go towards abstracting the mechanism from the widget implementation itself and having an external mechanism perform the pick and drop work as this would remove a huge amount of code and be much easier to manage/test.

=== Initial Implementation ===
The initial mechanism we have is for every possible pebble source, we set the mode from its current (default) pick_and_drop_mode to configurable_target_menu_mode via the call 'set_configurable_target_menu_mode'. By default the PND mode is set to create a PND context menu comprosing a list of all the potential target sources, this is useful for testing although it can be completely automated for a one level menu due to the addition of a set_target_data_function. This will be mentioned later.

== Approach could be automated but would need design change of command widget factories ==
I had originally envisaged that each potential pick and drop target for a given pebble would give enough detail to be able to construct a context menu automatically as each menu item in the context menu should relate to a single pick and drop pebble target, I added code to be able to retrieve the menu data (text and pixmap) for a pebble target. To construct a hierarchical menu the PND target name for a given pebble would mention the hierarchy (such as "Show / Descendents") In theory, every command should be able to take a pebble, for example when you select text you may be creating a selection pebble which fits in the cut copy and paste command targets. However the docking mechanism introduction made this task more difficult as none of the droppable targets are no longer descendents of EV_PICK_AND_DROPABLE so Vision2 has no notion of them (they were via deferring the drop actions from the parent and so are hidden from the mechanism) This makes an automatic approach not very practical so the menus will have to be hard-coded.

== Hard Coded Approach ==

To EV_PICK_AND_DROPABLE, which is the source of every PND pick, I have added set_configurable_target_menu_handler. What this does is allow an agent to be passed that is called by the configurable target menu mechanism when right clicked over a valid pebble.

The signature is as follows

PROCEDURE [ANY. TUPLE [a_menu: EV_MENU; a_target_list: ARRAYED_LIST [EV_PND_TARGET_DATA]; a_source: EV_PICK_AND_DROPABLE; a_pebble: ANY]

a_menu: EV_MENU - Menu built by mechanism that already has an initialized 'Pick' entry that allows reversion to the existing PND mode'.
a_target_list: ARRAYED_LIST [EV_PND_TARGET_DATA] - List of meta data of all potential targets for the given pebble
a_source: EV_PICK_AND_DROPABLE - Object where the PND began.
a_pebble: ANY - Pebble in question.

2006-04-07T19:08:27Z

King:

[[Category:WEL]]

==There are 3 different kinds of hooks now. Which one is better?==

* 1.Old one in svn. Use WM_MOUSE.

Problems:
1. Does not work with pointer button pressed and when pointer moves outside the same process.
2. Cursor will be changed outside the same process.

* 2.Wel hook with low level mouse hook (WH_MOUSE_LL) and normal hook (WH_MOUSE).

Problems:
1. Cursor will be changed outside the same process.
2. Low level mouse hook does not work on Windows 98.

* 3.Wel hook with journal record hook (WH_JOURNALRECORD) and normal hook (WH_MOUSE).

Problems:
1. Cursor will change between our application's cursor and another processes cursor.
2. Low level mouse hooks do not work on Windows 98.

* 4.Wel hook (heavy capture) and Windows setCapture (normal capture) working at the same time.

Problems:
1. Does not work when pointer button pressed and pointer move outside the same process EXCEPT the first time.
Advantage:
1. Actually, in most cases users only care about the first time when pointer button pressed.

* Final words:

If I can find a way to stop Windows from changing mousr cursor, I think "2" is perfect. (But is still not supported by Windows98)